分类 系统运维 下的文章

对 CrowdSec 的配置更改,在不到一分钟的时间内阻止了一个 7000 台机器的僵尸网络的攻击。

2020 年,我们的生活和工作方式在短短几天内被彻底颠覆。随着 COVID-19 开始在全球范围内蔓延,我们将工作带回家,与同事、朋友和家人保持在线联系成为关键的必需品。这为黑客造成破坏打开了大门。例如,根据 Neustar 的数据,今年上半年全球的分布式拒绝服务(DDOS) 攻击增长了 151%

CrowdSec 是一个开源的安全引擎,它可以分析访问者的行为,并提供适应各种攻击的响应。它能解析来自各种来源的日志,并应用启发式方案来识别攻击性行为,并防范大多数攻击类别。并且,它与其它安装的 CrowdSec 系统共享该情报。每次 IP 地址被阻止时,它都会通知整个用户社区。这就创建了一个实时、协作的 IP 信誉数据库,利用人群的力量使互联网更加安全。

CrowdSec 如何工作:案例研究

Sorf Networks 是一家总部位于土耳其的技术公司,为客户提供高配置的托管服务器和 DDoS 防护解决方案,它提供了一个 CrowdSec 工作的例子。Sorf 的一个客户每天都会遇到来自 1 万多台机器僵尸网络的 DDoS 攻击,并努力寻找一种能够满足技术要求的解决方案来及时处理这些攻击。

虽然客户采取了一般的预防措施来缓解这些攻击,比如引入 JavaScript(JS) 挑战 challenges 、限速等,但这些措施在整个攻击面并不可行。一些 URL 需要被非常基本的软件使用,而这些软件不支持 JS 挑战。黑客就是黑客,这正是他们每天的目标:链条上最薄弱的环节。

Sorf Networks 首先使用 Fail2ban(这启发了 CrowdSec)为其客户建立了一个 DDoS 缓解策略。它在一定程度上帮助了客户,但它太慢了。它需要 50 分钟来处理日志和处理 7000 到 10000 台机器的 DDoS 攻击。这使得它在这种情况下没有效果。另外,因为它没有禁止 IP,日志会持续堆积,它需要每秒处理几千条日志,这是不可能的。

在使用租用的僵尸网络进行的 DDoS 测试中,一次攻击可以高达每秒 6700 个左右的请求,这些请求来自 8600 个独立 IP。这是对一台服务器流量的捕捉:

 title=

虽然 CrowdSec 技术可以应对巨大的攻击,但其默认设置每秒只能处理约 1000 个端点。Sorf 需要一个量身定做的配置来处理单台机器上这么多的流量。

Sorf 的团队对 CrowdSec 的配置进行了修改,以显著提高其吞吐量来处理日志。首先,它去掉了高消耗且非关键的 富集 enrichment 解析器,例如 GeoIP 富集。它还将允许的 goroutine 的默认数量从一个增加到五个。之后,团队又用 8000 到 9000 台主机做了一次实测,平均每秒 6000 到 7000 个请求。这个方案是有代价的,因为 CrowdSec 在运行过程中吃掉了 600% 的 CPU,但其内存消耗却保持在 270MB 左右。

然而,结果却显示出明显的成功:

  • 在一分钟内,CrowdSec 能够处理所有的日志
  • 95% 的僵尸网络被禁止,攻击得到有效缓解
  • 15 个域现在受到保护,不受 DDoS 攻击

根据 Sorf Networks 的总监 Cagdas Aydogdu 的说法,CrowdSec 的平台使团队“能够在令人难以置信的短时间内提供一个世界级的高效防御系统”。


本文改编自如何用 CrowdSec 在 1 分钟内阻止 7000 台机器的僵尸网络,原载于 CrowdSec 网站。


via: https://opensource.com/article/20/12/open-source-vs-ddos-attacks

作者:Philippe Humeau 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

从集中会话记录、chroot 支持到 Python API,sudo 1.9 提供了许多新功能。

当你想在 POSIX 系统上执行一个操作时,最安全的方法之一就是使用 sudo 命令。与以 root 用户身份登录并执行命令可能是个危险的操作不同,sudo 授予任何被系统管理员指定为 “sudoer”的用户临时权限,来执行通常受限制的活动。

几十年来,这个系统帮助 Linux、Unix 和 macOS 系统免受愚蠢的错误和恶意攻击,它是当今所有主要 Linux 发行版的默认管理机制。

当在 2020 年 5 月发布 sudo 1.9 时,它带来了许多新功能,包括集中收集会话记录,支持 sudo 内的 chroot,以及 Python API。如果你对其中的任何一项感到惊讶,请阅读我的文章,了解一些 sudo 鲜为人知的功能

sudo 不仅仅是一个管理命令的前缀。你可以微调权限,记录终端上发生的事情,使用插件扩展sudo,在 LDAP 中存储配置,进行广泛的日志记录,以及更多。

1.9.0 版本和后续的小版本增加了各种新功能(我将在下面介绍),包括:

  • 一个集中收集 sudo 会话记录的记录服务
  • 审计插件 API
  • 审批插件 API
  • Python 对插件的支持
  • sudo 内置 chroot 和 CWD 支持(从 1.9.3 开始)

哪里可以得到 sudo 1.9?

大多数的 Linux 发行版仍然封装了上一代的 sudo(1.8 版本),并且在长期支持(LTS)的发行版中会保持这个版本数年。据我所知,提供了最完整的 sudo 1.9 包的 Linux 发行版是 openSUSETumbleweed,它是一个滚动发行版,而且该 sudo 包的子包中有 Python 支持。最近的 Fedora 版本包含了 sudo 1.9,但没有 Python 支持。FreeBSD Ports 有最新的 sudo 版本,如果你自己编译 sudo 而不是使用软件包,你可以启用 Python 支持。

如果你喜欢的 Linux 发行版还没有包含 sudo 1.9,请查看 sudo 二进制页面来查看是否有现成的包可以用于你的系统。这个页面还提供了一些商用 Unix 变种的软件包。

像往常一样,在你开始试验 sudo 设置之前,确保你知道 root 密码。是的,即使在 Ubuntu 上也是如此。有一个临时的“后门”是很重要的;如果没有这个后门,如果出了问题,你就必须得黑掉自己的系统。记住:语法正确的配置并不意味着每个人都可以在该系统上通过 sudo 做任何事情!

记录服务

记录服务可以集中收集会话记录。与本地会话记录存储相比,这有很多优势:

  • 更方便地在一个地方进行搜索,而不是访问各个机器来寻找记录
  • 即使在发送机器停机的情况下也可以进行记录
  • 本地用户若想掩盖其轨迹,不能删除记录

为了快速测试,你可以通过非加密连接向记录服务发送会话。我的博客中包含了说明,可以在几分钟内完成设置。对于生产环境,我建议使用加密连接。有很多可能性,所以请阅读最适合你的环境的文档

审计插件 API

新的审计插件 API 不是一个用户可见的功能。换句话说,你不能从 sudoers 文件中配置它。它是一个 API,意味着你可以从插件中访问审计信息,包括用 Python 编写的插件。你可以用很多不同的方式来使用它,比如当一些有趣的事情发生时,从 sudo 直接发送事件到 Elasticsearch 或日志即服务(LaaS)上。你也可以用它来进行调试,并以任何你喜欢的格式将其他难以访问的信息打印到屏幕上。

根据你使用它的方式,你可以在 sudo 插件手册页(针对 C 语言)和 sudo Python 插件手册中找到它的文档。在 sudo 源代码中可以找到 Python 代码示例,在我的博客上也有一个简化的例子

审批插件 API

审批插件 API 可以在命令执行之前加入额外的限制。这些限制只有在策略插件成功后才会运行,因此你可以有效地添加额外的策略层,而无需更换策略插件,进而无需更换 sudoers。可以定义多个审批插件,而且所有插件都必须成功,命令才能执行。

与审计插件 API 一样,你可以从 C 和 Python 中使用它。我博客上记录的示例 Python 代码是对该 API 的一个很好的介绍。一旦你理解了它是如何工作的,你就可以扩展它来将 sudo 连接到工单系统,并且只批准有相关开放工单的会话。你也可以连接到人力资源数据库,这样只有当班的工程师才能获得管理权限。

Python 对插件的支持

尽管我不是程序员,但我最喜欢的 sudo 1.9 新特性是 Python 对插件的支持。你可以用 Python 也能使用 C 语言调用大部分 API。幸运的是,sudo 对性能不敏感,所以运行速度相对较慢的 Python 代码对 sudo 来说不是问题。使用 Python 来扩展 sudo 有很多优势:

  • 更简单、更快速的开发
  • 不需要编译;甚至可以通过配置管理分发代码
  • 许多 API 没有现成的 C 客户端,但有 Python 代码

除了审计和审批插件 API 之外,还有一些其他的 API,你可以用它们做一些非常有趣的事情。

通过使用策略插件 API,你可以取代 sudo 策略引擎。请注意,你将失去大部分的 sudo 功能,而且没有基于 sudoers 的配置。这在小众情况下还是很有用的,但大多数时候,最好还是继续使用 sudoers,并使用审批插件 API 创建额外的策略。如果你想尝试一下,我的 Python 插件介绍提供了一个非常简单的策略:只允许使用 id 命令。再次确认你知道 root 密码,因为一旦启用这个策略,它就会阻止任何实际使用 sudo 的行为。

使用 I/O 日志 API,你可以访问用户会话的输入和输出。这意味着你可以分析会话中发生了什么,甚至在发现可疑情况时终止会话。这个 API 有很多可能的用途,比如防止数据泄露。你可以监控屏幕上的关键字,如果数据流中出现任何关键字,你可以在关键字出现在用户的屏幕上之前中断连接。另一种可能是检查用户正在输入的内容,并使用这些数据来重建用户正在输入的命令行。例如,如果用户输入 rm -fr /,你可以在按下回车键之前就断开用户的连接。

组插件 API 允许非 Unix 组的查找。在某种程度上,这与审批插件 API 类似,因为它也扩展了策略插件。你可以检查一个用户是否属于一个给定的组,并在后面的配置部分基于此采取行动。

chroot 和 CWD 支持

sudo 的最新功能是支持 chroot 和改变工作目录(CWD),这两个选项都不是默认启用的,你需要在 sudoers 文件中明确启用它们。当它们被启用时,你可以调整目标目录或允许用户指定使用哪个目录。日志反映了这些设置何时被使用。

在大多数系统中,chroot 只对 root 用户开放。如果你的某个用户需要 chroot,你需要给他们 root 权限,这比仅仅给他们 chroot 权限要大得多。另外,你可以通过 sudo 允许访问 chroot 命令,但它仍然允许漏洞,他们可以获得完全的权限。当你使用 sudo 内置的 chroot 支持时,你可以轻松地限制对单个目录的访问。你也可以让用户灵活地指定根目录。当然,这可能会导致灾难(例如,sudo --chroot / -s),但至少事件会被记录下来。

当你通过 sudo 运行一个命令时,它会将工作目录设置为当前目录。这是预期的行为,但可能有一些情况下,命令需要在不同的目录下运行。例如,我记得使用过一个应用程序,它通过检查我的工作目录是否是 /root 来检查我的权限。

尝试新功能

希望这篇文章能启发你仔细研究一下 sudo 1.9。集中会话记录比在本地存储会话日志更加方便和安全。chroot 和 CWD 支持为你提供了额外的安全性和灵活性。而使用 Python 来扩展 sudo,可以很容易地根据你的环境来定制 sudo。你可以通过使用最新的 Linux 发行版或 sudo 网站上的即用型软件包来尝试这些新功能。

如果你想了解更多关于 sudo 的信息,这里有一些资源:


via: https://opensource.com/article/20/10/sudo-19

作者:Peter Czanik 选题:lujun9972 译者:wxy 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

LVM 是一个逻辑卷管理工具,包括分配磁盘、条带化、镜像和调整逻辑卷的大小。它在 Fedora 安装中被普遍使用(在 BTRFS 作为默认文件系统之前是 LVM + Ext4)。但是你是否曾经遇到过启动系统时,GNOME 提示 home 卷几乎没有空间了!幸运的是,很有可能有一些空间在另一个卷中,而未被使用,可以用于重新分配。下面就来看看如何用 LVM 回收硬盘空间。

在卷之间轻松重新分配空间的关键是逻辑卷管理器(LVM)。Fedora 32 及以前的系统默认使用 LVM 来划分磁盘空间。这种技术类似于标准的硬盘分区,但 LVM 更加灵活。LVM 不仅可以实现灵活的卷大小管理,还可以实现一些高级功能,比如读写快照、在多个硬盘上进行数据条带化或镜像、将高速硬盘作为慢速硬盘的缓存等等。所有这些高级选项可能会让人有点不知所措,但调整卷的大小很简单的。

LVM 基础

卷组(VG)作为 LVM 系统中的主要容器。默认情况下,Fedora 只定义了一个卷组,但你可以根据需要定义多个卷组。实际的硬盘和硬盘分区被添加到卷组中作为物理卷(PV)。物理卷会将可用的空间添加到卷组中。一个典型的 Fedora 安装有一个格式化的启动分区,其余的硬盘是一个配置为 LVM 物理卷的分区。

从这个可用空间池中,卷组分配了一个或多个逻辑卷(LV)。这些卷类似于硬盘分区,但没有磁盘上连续空间的限制。LVM 的逻辑卷甚至可以跨越多个设备!就像硬盘分区一样,逻辑卷有一个定义的大小,可以包含任何文件系统,然后可以挂载到特定的目录。

需要什么

在 gnome-disks 应用中确认系统使用 LVM ,并确保其他卷中有可用的空间。如果没有可以从另一个卷中回收的空间,这个指南就没有用。还需要一个 Fedora 临场 CD/USB。任何需要收缩的文件系统都必须卸载。从 临场 Live 镜像运行,可以让硬盘上的所有卷保持未挂载状态,甚至包括像 //home 这样的重要目录。

Use gnome-disks to verify free space

一句话警告

按照这个指南,应该不会丢失任何数据,但它确实会使用一些非常底层和强大的命令。一个错误可能会破坏硬盘上的所有数据。所以要先备份磁盘上的所有数据!

调整 LVM 卷的大小

开始时,启动 Fedora 临场镜像并在对话框中选择 “Try Fedora”。接下来,使用 “Run Command” 启动 “blivet-gui” 应用(按 Alt-F2,输入 blivet-gui,然后按回车)。选择左侧 “LVM” 下的卷组。逻辑卷在右边。

Explore logical volumes in blivet-gui

逻辑卷标签由卷组名称和逻辑卷名称组成。在本例中,卷组是 fedora_localhost-live,分配了 homerootswap 逻辑卷。要找到完整的卷,选择每一个卷,点击“齿轮”图标,然后选择 “resize”。调整大小对话框中的滑块表示卷的允许大小。左边的最小值是文件系统中已经使用的空间,所以这是最小可能的尺寸大小(不删除数据)。右边的最大值是基于卷组中的最大可用空间。

Resize dialog in blivet-gui

灰色的 “resize” 选项意味着该卷已经满了,而且卷组中没有可用空间。

现在可以更改大小了!查看所有的卷,就像上面的截图那样,找到一个有足够空间的卷。并像上面的截图那样,在所有的卷中找到一个有大量额外空间的卷。向左移动滑块来设置新的大小。腾出足够的空间对整个卷有用,但仍然要为未来的数据增长留出足够的空间。否则,这个卷将是下一个被填满的卷。

点击 “resize”,注意卷列表中出现了一个新项目:“free space”。现在选择这次要调整的卷,并将滑块一直向右移动。按 “resize” 键,并查看新改进的卷的布局。然而,硬盘驱动器上的任何东西现在都还没有改变。点击“勾选”选项将更改提交到磁盘。

Review changes in blivet-gui

查看更改的摘要,如果一切看起来都是正确的,点击 “Ok” 继续。等待 “blivet-gui” 完成。现在重新启动回到 Fedora,可以使用之前被充满的卷上的新空间了。

为未来计划

要知道任何特定卷在未来需要多少空间是很困难的。与其立即分配所有可用的空闲空间,不如考虑在卷组中留出空闲空间。事实上,Fedora Server 默认在卷组中保留空间。当一个卷处于在线和使用中时,扩展卷是可能的。不需要临场镜像或重启。当一个卷几乎满的时候,可以使用部分可用空间轻松扩展卷并继续工作。遗憾的是,默认的磁盘管理器 gnome-disks 不支持 LVM 卷的大小调整,所以安装 blivet-gui 作为图形化管理工具。另外,还有一个简单的终端命令来扩展卷:

lvresize -r -L +1G /dev/fedora_localhost-live/root

总结

用 LVM 回收硬盘空间只是 LVM 功能的表面。大多数人,特别是在桌面中,可能不需要更高级的功能。然而,当需要的时候,LVM 就在那里,尽管它的实现可能会变得有点复杂。从 Fedora 33 开始,BTRFS 是默认的文件系统,没有 LVM。BTRFS 可以更容易管理,同时对于大多数常见的使用来说也足够灵活。查看最近 Fedora Magazine 关于 BTRFS 的文章了解更多。


via: https://fedoramagazine.org/reclaim-hard-drive-space-with-lvm/

作者:Troy Curtis Jr 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

用 Node.js 或其他编程语言为你提供启动基础设施所需的一切服务。

当你在 IT 和技术的世界里遨游时,你会反复遇到一些术语。其中有些术语很难量化,随着时间的推移,可能会有不同的含义。“DevOps” 就是一个例子,这个词似乎(在我看来)会根据使用它的人而改变;最初的 DevOps 先驱者可能甚至不认识我们今天所说的 DevOps。

如果你是一个软件开发者,“ 基础架构即代码 Infrastructure as Code ”(IaC)可能是其中一个术语。IaC 是使用与你编写面向用户的功能相同的软件开发实践来声明应用程序运行的基础设施。这通常意味着使用 GitMercurial 等工具进行版本控制,使用 Puppet、Chef 或 Ansible 进行配置管理。在基础设施供应层,最常见的技术是 CloudFormation(专用于 AWS),或开源替代品 Terraform,用来创建供你的应用程序运行的混合云资源。

在配置管理领域有很好产品可供选择,可以将 IaC 写成配置文件或首选的编程语言,但这种选择在基础设施供应领域并不常见。

Pulumi 提供了一个使用标准编程语言来定义基础设施的方式。它支持一系列语言,包括 JavaScriptTypeScriptGoPythonC#)。就像 Terraform 一样,Pulumi 对许多熟悉的云提供商有一流的支持,比如 AWSAzureGoogle Cloud其他提供商

在本文中,我将向你展示如何使用 Pulumi 以 Node.js 编写基础设施。

先决条件

首先,确保你已经做好了使用 Pulumi 的准备。Pulumi 支持所有主流的操作系统,所以你安装其先决条件的方法取决于你使用的操作系统。

首先,安装你喜欢的编程语言的解释器。我将使用 TypeScript,所以我需要安装 node 二进制。请查阅 Node 的安装说明,了解你的操作系统的信息。你可以在 MacLinux 上使用 Homebrew 来安装:

brew install node

在 Linux 上,你可以使用你常用的软件包管理器,如 aptdnf

$ sudo dnf install nodejs

无论哪种情况,结果都应该是 node 二进制文件在你的 $PATH 中可用。要确认它是可访问的,运行:

node --version

接下来,安装 Pulumi 命令行界面(CLI)。你可以在 Pulumi 的文档中找到针对不同操作系统的安装说明。在 Mac 或 Linux 上使用 brew

brew install pulumi

另外,你也可以使用安装脚本。首先下载并审查它,然后执行它:

$ curl -fsSL --output pulumi_installer.sh https://get.pulumi.com/
$ more  pulumi_installer.sh
$ sh ./pulumi_installer.sh

同样,我们所希望的结果是在你的路径上有 pulumi 二进制。检查版本以确保你已经准备好了:

pulumi version
v2.5.0

配置 Pulumi

在你开始配置任何基础设施之前,给 Pulumi 一个存储其状态的地方。

Pulumi 将其状态存储在后端。默认的后端是 Pulumi 的软件即服务(它有一个针对个人用户的免费计划),但在这个例子中,我使用替代的文件后端。文件后端将在你的本地文件系统上创建一个文件来存储状态:

pulumi login --local

如果你打算和别人分享这个项目,文件后台可能不是一个好的起点。Pulumi 还可以将其状态存储在 AWS S3 等云对象存储中。要使用它,请创建一个 S3 bucket 并登录:

pulumi login --cloud-url s3://my-pulumi-state-bucket

现在你已经登录到了状态后端,你可以创建一个项目和一个堆栈了!

在你开始创建 Pulumi 项目之前,请先了解以下 Pulumi 术语,你将在本教程中看到这些术语。

项目

项目 project 是一个包含 Pulumi.yaml 文件的目录。这个文件包含了 Pulumi 需要知道的元数据,以便进行它的工作。在 Pulumi.yaml 文件中可以找到的示例字段有:

  • 运行时(例如,Python、Node、Go、.Net)
  • 项目说明(如“我的第一个 Pulumi 项目”)
  • 项目名称

项目是一个松散的概念,可以满足你的需求。一般来说,一个项目包含了一系列的资源,这些资源是你想要提供和控制的东西。你可以选择拥有资源很少的小型 Pulumi 项目,也可以选择包含所有你需要的资源的大型项目。随着你对 Pulumi 越来越熟悉,你想如何布局你的项目会变得更加清晰。

堆栈

Pulumi 堆栈 stack 允许你根据可配置的值来区分你的 Pulumi 项目。一个常见的用途是将一个项目部署到不同的环境,如开发或生产环境,或不同的地区,如欧洲、中东和非洲以及美国。

在入门时,你不大需要一个复杂的堆栈设置,所以本演练使用默认的堆栈名称 dev

在 IaC 中使用 TypeScript

你可以使用方便的 pulumi new 命令来 初建 bootstrap 一个 Pulumi 项目。new 命令有一大堆标志和选项,可以帮助你入门 Pulumi,所以请继续创建你的第一个项目:

$ pulumi new typescript
This command will walk you through creating a new Pulumi project.

Enter a value or leave blank to accept the (default), and press <ENTER>.
Press ^C at any time to quit.

project name: (pulumi) my-first-project
project description: (A minimal TypeScript Pulumi program) My very first Pulumi program
Created project 'my-first-project'

Please enter your desired stack name.
To create a stack in an organization, use the format <org-name>/<stack-name> (e.g. `acmecorp/dev`).
stack name: (dev) dev
Created stack 'dev'

Installing dependencies...


> node scripts/postinstall

added 82 packages from 126 contributors and audited 82 packages in 2.84s

13 packages are looking for funding
  run `npm fund` for details

found 0 vulnerabilities

Finished installing dependencies

Your new project is ready to go! ✨

To perform an initial deployment, run 'pulumi up'

这里发生了很多事情,我将其展开来说:

第一部分是为你的 Pulumi 项目确定一个模板。我选择了通用的 typescript 选项,但是有很多选项可供选择

这个 new 命令从你的模板库中抓取模板,并将这个文件复制到本地,包括运行时的依赖关系(在本例中是 package.json)。

new 命令通过在这个目录下运行 npm install 来安装这些依赖关系。然后 npm install 下载并安装运行 Pulumi 程序所需的一切,在这种情况下就是:@pulumi/pulumi NPM 包。

你已经准备好创建你的第一个资源了!

创建你的第一个云资源

资源是一个由你的基础设施供应软件生命周期进行管理的东西。资源一般是一个 云提供商对象 cloud provider object ,比如 S3 桶。Pulumi 的提供商处理 Pulumi 资源,提供商是具体的云提供商。Pulumi 有大约 40 个提供商可供你使用,但对于你的第一个资源,使用一个最简单的: 随机提供商 random provider

随机提供者顾名思义:它幂等地创建一个随机资源(例如,可以是一个字符串),并将其存储在 Pulumi 状态中。

使用 npm 将其添加到你的 Pulumi 项目中作为依赖关系:

npm install @pulumi/random

npm 包管理器下载并安装随机提供者包,并为你安装。现在你已经准备好编写你的 Pulumi 程序了。

当你之前生成你的项目时,Pulumi 的初建过程创建了一个 index.ts TypeScript 文件。在你喜欢的集成开发环境(IDE)中打开它,并添加你的第一个资源:

import * as pulumi from "@pulumi/pulumi";
import * as random from "@pulumi/random";

const password = new random.RandomString(`password`, {
    length: 10
})

如果你对 TypeScript 或 JavaScript 非常熟悉,这看起来会非常熟悉,因为它是用你熟悉的编程语言编写的。如果你使用的是 Pulumi 支持的其他语言之一,也是一样的。这里是之前的那个随机资源,但这次是用 Python 写的:

import pulumi_random as random

password = random.RandomString("password", length=10)

一个 Pulumi 项目目前只支持单一一种语言,但每个项目都可以引用其他语言编写的项目,这对于多语言团队的成员来说是一个很有用的技巧。

你已经编写了第一个 Pulumi 资源。现在你需要部署它。

离开编辑器,回到命令行。在你的项目目录下,运行 pulumi up,然后看着神奇的事情发生:

pulumi up

Previewing update (dev):
     Type                          Name                  Plan
 +   pulumi:pulumi:Stack           my-first-project-dev  create
 +   └─ random:index:RandomString  password              create

Resources:
    + 2 to create

Do you want to perform this update? yes
Updating (dev):
     Type                          Name                  Status
 +   pulumi:pulumi:Stack           my-first-project-dev  created
 +   └─ random:index:RandomString  password              created

Resources:
    + 2 created

Duration: 2s

Permalink: file:///Users/lbriggs/.pulumi/stacks/dev.json

太好了,你有了第一个 Pulumi 资源! 虽然你可能很享受这种成就感,但不幸的是,这个随机资源并没有那么有用:它只是一个随机的字符串,你甚至看不到它是什么。先解决这部分问题。修改你之前的程序,在你创建的常量中加入 export

import * as pulumi from "@pulumi/pulumi";
import * as random from "@pulumi/random";

export const password = new random.RandomString(`password`, {
    length: 10
})

重新运行 pulumi up,看看输出:

pulumi up
Previewing update (dev):
     Type                 Name                  Plan
     pulumi:pulumi:Stack  my-first-project-dev

Outputs:
  + password: {
      + id             : "&+r?{}J$J7"
      + keepers        : output<string>
      + length         : 10
      + lower          : true
      + minLower       : 0
      + minNumeric     : 0
      + minSpecial     : 0
      + minUpper       : 0
      + number         : true
      + overrideSpecial: output<string>
      + result         : "&+r?{}J$J7"
      + special        : true
      + upper          : true
      + urn            : "urn:pulumi:dev::my-first-project::random:index/randomString:RandomString::password"
    }

Resources:
    2 unchanged

Do you want to perform this update? yes
Updating (dev):
     Type                 Name                  Status
     pulumi:pulumi:Stack  my-first-project-dev

Outputs:
  + password: {
      + id        : "&+r?{}J$J7"
      + length    : 10
      + lower     : true
      + minLower  : 0
      + minNumeric: 0
      + minSpecial: 0
      + minUpper  : 0
      + number    : true
      + result    : "&+r?{}J$J7"
      + special   : true
      + upper     : true
      + urn       : "urn:pulumi:dev::my-first-project::random:index/randomString:RandomString::password"
    }

Resources:
    2 unchanged

Duration: 1s
Permalink: file:///Users/lbriggs/.pulumi/stacks/dev.json

现在你可以在 Outputsresult 部分下看到一个随机生成的字符串。你现在可以看到你创建的资源有很多属性。

这一切都很好,但如果你想享受 IaC,你得提供一些随机字符串以外的东西。试试吧。

部署一个容器

到目前为止,你已经通过安装依赖关系和注册一个简单的随机资源来 体验了初建你的 Pulumi。现在部署一些实际的基础设施,尽管是在你的本地机器上。

首先,将 @pulumi/docker 提供者添加到你的堆栈中。使用你选择的包管理器将其添加到项目中:

npm install @pulumi/docker

你已经从 npm 下拉了 Pulumi Docker 提供商包,这意味着你现在可以在你的项目中创建 Docker 镜像。

如果你的机器上还没有安装 Docker,现在是一个极好的时机去安装它。说明将取决于你的操作系统,所以看看 Docker 的安装页面了解信息。

再次打开你喜欢的 IDE,运行一个 Docker 容器。修改你之前的 index.ts 文件,让它看起来像这样:

import * as pulumi from "@pulumi/pulumi";
import * as random from "@pulumi/random";
import * as docker from "@pulumi/docker";

const password = new random.RandomString(`password`, {
    length: 10
})

const container = new docker.Container(`my-password`, {
    image: 'hashicorp/http-echo',
    command: [ pulumi.interpolate`-text=Your super secret password is: ${password.result}` ],
    ports: [{
        internal: 5678,
        external: 5678,
    }]
})

export const id = container.id

这将创建一个容器,创建一个 Web 服务器。Web 服务器的输出是你随机生成的字符串,在本例中是一个密码。运行这个,看看会发生什么:

pulumi up

Previewing update (dev):
     Type                       Name                  Plan
     pulumi:pulumi:Stack        my-first-project-dev
 +   └─ docker:index:Container  my-password           create

Outputs:
  + id      : output<string>
  ~ password: {
        id        : "&+r?{}J$J7"
        length    : 10
        lower     : true
        minLower  : 0
        minNumeric: 0
        minSpecial: 0
        minUpper  : 0
        number    : true
        result    : "&+r?{}J$J7"
        special   : true
        upper     : true
        urn       : "urn:pulumi:dev::my-first-project::random:index/randomString:RandomString::password"
    }

Resources:
    + 1 to create
    2 unchanged

Do you want to perform this update? yes
Updating (dev):
     Type                       Name                  Status
     pulumi:pulumi:Stack        my-first-project-dev
 +   └─ docker:index:Container  my-password           created

Outputs:
  + id      : "e73b34aeca34a64b72b61b0b9b8438637ce28853937bc359a1528ca99f49ddda"
    password: {
        id        : "&+r?{}J$J7"
        length    : 10
        lower     : true
        minLower  : 0
        minNumeric: 0
        minSpecial: 0
        minUpper  : 0
        number    : true
        result    : "&+r?{}J$J7"
        special   : true
        upper     : true
        urn       : "urn:pulumi:dev::my-first-project::random:index/randomString:RandomString::password"
    }

Resources:
    + 1 created
    2 unchanged

Duration: 2s
Permalink: file:///Users/lbriggs/.pulumi/stacks/dev.json

你会注意到在 Outputs 部分,你输出的值已经改变了,它只是一个 Docker 容器 ID。检查你的非常简单的密码生成器是否工作:

curl http://localhost:5678
Your super secret password is: &+r?{}J$J7

就是这样! 你刚刚用 TypeScript 配置了你的第一个基础架构。

关于 Pulumi 输出的快速说明

你会注意到在创建 Docker 容器的代码中,它使用了一个特殊的 pulumi.interpolate 调用。如果你熟悉 TypeScript,你可能会好奇为什么需要这样做(因为它是 Pulumi 特有的)。这有一个有趣的原因。

当 Pulumi 创建一个资源时,直到程序执行时有一些值是 Pulumi 不知道的。在 Pulumi 中,这些值被称为 Outputs。这些 Outputs 可以在上面的代码中看到,例如,在你的第一个随机资源中,你使用 export 关键字来输出随机资源的属性,你还输出了你创建的容器的容器 ID。

因为 Pulumi 直到执行时才知道这些 Outputs 的值,所以在操作字符串时,它需要特殊的助手来使用它们。如果你想了解更多关于这个特殊的编程模型,请观看这个短视频

总结

随着混合云基础架构中出现的复杂性,IaC 在很多方面都有了发展。在基础设施供应领域,Pulumi 是一个很好的选择,它可以使用你最喜欢的编程语言来供应你所需要的一切基础设施,然后你可以在你最喜欢的配置管理工具中进行标记,以采取下一步措施。


via: https://opensource.com/article/20/8/infrastructure-as-code-pulumi

作者:Lee Briggs 选题:lujun9972 译者:wxy 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

许多计算机使用 网络时间协议 Network Time Protocol (NTP)通过互联网来同步系统时钟。NTP 是少数几个仍在普遍使用的不安全的互联网协议之一。攻击者如果能够观察到客户端和服务器之间的网络流量,就可以向客户端提供虚假的数据,并根据客户端的实现和配置,强迫其将系统时钟设置为任何时间和日期。如果客户端的系统时钟不准确,一些程序和服务就可能无法工作。例如,如果根据客户端的系统时钟,Web 服务器的证书似乎已经过期,Web 浏览器将无法正常工作。可以使用 网络时间安全 Network Time Security (NTS)来保证 NTP 的安全。

Fedora 33 [1] 是第一个支持 NTS 的 Fedora 版本。NTS 是一种新的 NTP 验证机制。它使客户端能够验证它们从服务器接收的数据包在传输过程中有没有被修改。当 NTS 启用时,攻击者唯一能做的就是丢弃或延迟数据包。关于 NTS 的更多细节,请参见 RFC8915

使用对称密钥可以很好地保证 NTP 的安全。遗憾的是,服务器必须为每个客户端配备不同的密钥,而且密钥必须安全地分发才行。这对于本地网络上的私有服务器来说可能是实用的,但它不能扩展到有着数百万客户端的公共服务器上。

NTS 包括一个 密钥建立 Key Establishment (NTS-KE)协议,它可以自动创建服务器与其客户端之间使用的加密密钥。它在 TCP 端口 4460 上使用 传输层安全 Transport Layer Security (TLS)。它被设计成可以扩展到非常多的客户端,而对准确性的影响最小。服务器不需要保存任何客户端特定的状态。它为客户提供 cookie,cookie 是加密的,包含验证 NTP 数据包所需的密钥。隐私是 NTS 的目标之一。客户端在每次服务器响应时都会得到一个新的 cookie,所以它不必重复使用 cookie。这可以防止被动观察者跟踪在网络之间迁移的客户端。

Fedora 中默认的 NTP 客户端是 Chrony。Chrony 在 4.0 版本中增加了 NTS 支持,但并没有改变默认配置。Chrony 仍然使用 pool.ntp.org 项目中的公共服务器,而且默认情况下 NTS 没有启用。

目前,支持 NTS 的公共 NTP 服务器非常少。两个主要的提供商是 Cloudflare 和 Netnod。Cloudflare 服务器分布在世界各地的不同地方。他们使用的是 任播 anycast 地址,应该可以让大多数客户到达一个接近的服务器。Netnod 服务器位于瑞典。在未来,我们可能会看到更多支持 NTS 的公共 NTP 服务器。

为了获得最佳的可靠性,配置 NTP 客户端的一般建议是至少有三个工作的服务器。为了达到最好的精度,建议选择距离较近的服务器,以减少网络延迟和非对称网络路由造成的不对称性。如果你不关心细粒度的精度,你可以忽略这个建议,使用任何你信任的 NTS 服务器,无论它们位于哪里。

如果你确实想要高准确度,但又没有近距离的 NTS 服务器,你可以将远处的 NTS 服务器和近处的非 NTS 服务器混合使用。但是,这样的配置不如只使用 NTS 服务器的配置安全。攻击者仍然不能强迫客户机接受任意时间,但他们确实对客户机的时钟及其估计精度有更大的控制权,这在某些环境下可能是不可接受的。

在安装程序中启用客户端 NTS

安装 Fedora 33 时,你可以在“Time & Date”对话框的“Network Time”配置中启用 NTS。在点击“+”(添加)按钮之前,请输入服务器的名称并检查 NTS 支持情况。你可以添加一个或多个具有 NTS 的服务器或池。要删除默认的服务器池(2.fedora.pool.ntp.org),请取消选中“Use”列中的相应标记。

Fedora 安装程序中的网络时间配置

在配置文件中启用客户端 NTS

如果你从之前的 Fedora 版本升级,或者你没有在安装程序中启用 NTS,你可以直接在 /etc/chrony.conf 中启用 NTS。除了推荐的 iburst 选项外,还可以对指定服务器使用 nts 选项。例如:

server time.cloudflare.com iburst nts
server nts.sth1.ntp.se iburst nts
server nts.sth2.ntp.se iburst nts

你还应该允许客户端将 NTS 密钥和 cookie 保存到磁盘上,这样它就不必在每次启动时重复 NTS-KE 会话。在 chrony.conf 中添加以下一行,如果还没有的话:

ntsdumpdir /var/lib/chrony

如果不想让 DHCP 提供的 NTP 服务器与你指定的服务器混在一起,请在 chrony.conf 中删除或注释以下一行:

sourcedir /run/chrony-dhcp

当你完成编辑 chrony.conf 后,保存你的更改并重新启动 chronyd 服务:

systemctl restart chronyd

检查客户端状态

在 root 用户下运行以下命令,检查 NTS 密钥建立是否成功:

# chronyc -N authdata
Name/IP address             Mode KeyID Type KLen Last Atmp  NAK Cook CLen
=========================================================================
time.cloudflare.com          NTS     1   15  256  33m    0    0    8  100
nts.sth1.ntp.se              NTS     1   15  256  33m    0    0    8  100
nts.sth2.ntp.se              NTS     1   15  256  33m    0    0    8  100

KeyIDTypeKLen 列应该有非零值。如果它们为零,请检查系统日志中是否有来自 chronyd 的错误信息。一个可能的故障原因是防火墙阻止了客户端与服务器的 TCP 端口(端口 4460)的连接。

另一个可能的故障原因是由于客户机的时钟错误而导致证书无法验证。这是 NTS 的先有鸡还是先有蛋的问题。你可能需要手动修正日期或暂时禁用 NTS,以使 NTS 正常工作。如果你的电脑有实时时钟,几乎所有的电脑都有,而且有好的电池做备份,这种操作应该只需要一次。

如果计算机没有实时时钟或电池,就像一些常见的小型 ARM 计算机(如树莓派)那样,你可以在 /etc/sysconfig/chronyd 中添加 -s 选项来恢复上次关机或重启时保存的时间。时钟会落后于真实时间,但如果电脑没有关机太久,服务器的证书也没有在离到期时间太近的时候更新,应该足以让时间检查成功。作为最后的手段,你可以用 nocerttimecheck 指令禁用时间检查。详情请参见chrony.conf(5) 手册页。

运行下面的命令来确认客户端是否在进行 NTP 测量:

# chronyc -N sources
MS Name/IP address         Stratum Poll Reach LastRx Last sample
===============================================================================
^* time.cloudflare.com           3   6   377    45   +355us[ +375us] +/-   11ms
^+ nts.sth1.ntp.se               1   6   377    44   +237us[ +237us] +/-   23ms
^+ nts.sth2.ntp.se               1   6   377    44   -170us[ -170us] +/-   22ms

Reach 列应该有一个非零值,最好是 377。上图所示的值 377 是一个八进制数,它表示最后八个请求都有有效的响应。如果启用了 NTS 的话,验证检查将包括 NTS 认证。如果该值一直很少或从未达到 377,则表明 NTP 请求或响应在网络中丢失了。众所周知,一些主要的网络运营商有中间设备,它可以阻止或限制大的 NTP 数据包的速率,以缓解利用 ntpd 的监控协议进行的放大攻击。不幸的是,这影响了受 NTS 保护的 NTP 数据包,尽管它们不会引起任何放大。NTP 工作组正在考虑为 NTP 提供一个替代端口,作为解决这个问题的办法。

在服务器上启用 NTS

如果你有自己的 NTP 服务器,运行着 chronyd,你可以启用服务器的 NTS 支持,让它的客户端安全同步。如果该服务器是其他服务器的客户端,它应该使用 NTS 或对称密钥与之同步。客户端假设同步链在所有服务器到主时间服务器之间是安全的。

启用服务器 NTS 类似于在 Web 服务器上启用 HTTPS。你只需要一个私钥和证书。例如,证书可以由 Let's Encrypt 权威机构使用 certbot 工具签署。当你有了密钥和证书文件(包括中间证书),在 chrony.conf 中用以下指令指定它们:

ntsserverkey /etc/pki/tls/private/foo.example.net.key
ntsservercert /etc/pki/tls/certs/foo.example.net.crt

确保之前在客户端配置中提到的 ntsdumpdir 指令存在于 chrony.conf 中。它允许服务器将其密钥保存到磁盘上,这样服务器的客户端在重启服务器时就不必获取新的密钥和 cookie 了。

重新启动 chronyd 服务:

systemctl restart chronyd

如果系统日志中没有来自 chronyd 的错误信息,那么它应该是可以接受客户端连接的,如果服务器有防火墙,则需要同时允许 UDP 123 和 TCP 4460 端口的 NTP 和 NTS-KE 服务。

你可以用下面的命令在客户端机器上进行快速测试:

$ chronyd -Q -t 3 'server foo.example.net iburst nts maxsamples 1'
2020-10-13T12:00:52Z chronyd version 4.0 starting (+CMDMON +NTP +REFCLOCK +RTC +PRIVDROP +SCFILTER +SIGND +ASYNCDNS +NTS +SECHASH +IPV6 +DEBUG)
2020-10-13T12:00:52Z Disabled control of system clock
2020-10-13T12:00:55Z System clock wrong by -0.001032 seconds (ignored)
2020-10-13T12:00:55Z chronyd exiting

如果你看到一个“System clock wrong”消息,说明它是正确工作的。

在服务器上,你可以使用下面的命令来检查它已经处理了多少个 NTS-KE 连接和认证的 NTP 数据包:

# chronyc serverstats
NTP packets received       : 2143106240
NTP packets dropped        : 117180834
Command packets received   : 16819527
Command packets dropped    : 0
Client log records dropped : 574257223
NTS-KE connections accepted: 104
NTS-KE connections dropped : 0
Authenticated NTP packets  : 52139

如果你看到非零的 “NTS-KE connections accepted” 和 “Authenticated NTP packets”,这意味着至少有一些客户端能够连接到 NTS-KE 端口,并发送一个认证的 NTP 请求。

  1. Fedora 33 Beta 安装程序包含一个较旧的 Chrony 预发布版本,它不能与当前的 NTS 服务器一起工作,因为 NTS-KE 端口已经改变。因此,在安装程序中的网络时间配置中,服务器总是显示为不工作。安装后,需要更新 chrony 包,才能与当前的服务器配合使用。 ↩︎

via: https://fedoramagazine.org/secure-ntp-with-nts/

作者:Miroslav Lichvar 选题:lujun9972 译者:wxy 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

通过使用网络绑定磁盘加密(NBDE),无需手动输入密码即可打开加密磁盘。

从安全的角度来看,对敏感数据进行加密以保护其免受窥探和黑客的攻击是很重要的。 Linux 统一密钥设置 Linux Unified Key Setup LUKS)是一个很好的工具,也是 Linux 磁盘加密的通用标准。因为它将所有相关的设置信息存储在分区头部中,所以它使数据迁移变得简单。

要使用 LUKS 配置加密磁盘或分区,你需要使用 cryptsetup 工具。不幸的是,加密磁盘的一个缺点是,每次系统重启或磁盘重新挂载时,你都必须手动提供密码。

然而, 网络绑定磁盘加密 Network-Bound Disk Encryption (NBDE) 可以在没有任何用户干预的情况下自动安全地解锁加密磁盘。它可以在一些 Linux 发行版中使用,包括从 Red Hat Enterprise Linux 7.4、CentOS 7.4 和 Fedora 24 开始,以及之后的后续版本。

NBDE 采用以下技术实现:

  • Clevis 框架:一个可插拔的框架工具,可自动解密和解锁 LUKS 卷
  • Tang 服务器:用于将加密密钥绑定到网络状态的服务

Tang 向 Clevis 客户端提供加密密钥。据 Tang 的开发人员介绍,这为密钥托管服务提供了一个安全、无状态、匿名的替代方案。

由于 NBDE 使用客户端-服务器架构,你必须同时配置客户端和服务器。你可以在你的本地网络上使用一个虚拟机作为 Tang 服务器。

服务器安装

用 sudo 安装 Tang:

sudo yum install tang -y

启用 Tang 服务器:

sudo systemctl enable tangd.socket --now

Tang 服务器工作在 80 端口,需加入到 firewalld 防火墙。添加相应的 firewalld 规则:

sudo  firewall-cmd --add-port=tcp/80 --perm
sudo firewall-cmd --reload

现在安装好了服务器。

客户端安装

在本例中,假设你已经添加了一个名为 /dev/vdc 的新的 1GB 磁盘到你的系统中。

使用 fdiskparted 创建主分区:

sudo fdisk /dev/vdc

完成以下步骤来安装客户端:

Welcome to fdisk (util-linux 2.23.2).

Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.

Device does not contain a recognized partition table
Building a new DOS disklabel with disk identifier 0x4a6812d4.

Command (m for help):

输入 n 来创建新的分区:

Partition type:
   p   primary (0 primary, 0 extended, 4 free)
   e   extended  
Select (default p):

按下回车键选择主分区:

Using default response p
Partition number (1-4, default 1):

按下回车键选择默认分区号:

First sector (2048-2097151, default 2048):
Using default value 2048
Last sector, +sectors or +size{K,M,G} (2048-2097151, default 2097151):

按回车键选择最后一个扇区:

Using default value 2097151
Partition 1 of type Linux and of size 1023 MiB is set

Command (m for help): wq

输入 wq 保存更改并退出 fdisk

The partition table has been altered!

Calling ioctl() to re-read partition table.
Syncing disks.

运行 partprobe 通知系统分区表的变化:

sudo partprobe

使用 sudo 安装 cryptsetup 软件包:

sudo yum install cryptsetup -y

使用 cryptsetup luksFormat 命令对磁盘进行加密。当提示时,你需要输入大写的 YES,并输入密码来加密磁盘:

sudo cryptsetup luksFormat /dev/vdc1
WARNING!
========
This will overwrite data on /dev/vdc1 irrevocably.

Are you sure? (Type uppercase yes):

Enter passphrase for /dev/vdc1:
Verify passphrase:

使用 cryptsetup luksOpen 命令将加密的分区映射到一个逻辑设备上。例如,使用 encryptedvdc1 作为名称。你还需要再次输入密码:

sudo cryptsetup luksOpen /dev/vdc1 encryptedvdc1
Enter passphrase for /dev/vdc1:

加密分区现在在 /dev/mapper/encryptedvdc1 中可用。

在加密的分区上创建一个 XFS 文件系统:

sudo mkfs.xfs /dev/mapper/encryptedvdc1

创建一个挂载加密分区的目录:

sudo mkdir /encrypted

使用 cryptsetup luksClose 命令锁定分区:

cryptsetup luksClose encryptedvdc1

使用 sudo 安装 Clevis 软件包:

sudo yum install clevis clevis-luks clevis-dracut -y

修改 /etc/crypttab,在启动时打开加密卷:

sudo vim /etc/crypttab

增加以下一行:

encryptedvdc1       /dev/vdc1  none   _netdev

修改 /etc/fstab,在重启时或启动时自动挂载加密卷:

sudo vim /etc/fstab

增加以下一行:

/dev/mapper/encryptedvdc1   /encrypted       xfs    _netdev        1 2

在这个例子中,假设 Tang 服务器的 IP 地址是 192.168.1.20。如果你喜欢,也可以使用主机名或域名。

运行以下 clevis 命令:

sudo clevis bind luks -d /dev/vdc1 tang '{"url":"http://192.168.1.20"}'
The advertisement contains the following signing keys:

rwA2BAITfYLuyNiIeYUMBzkhk7M

Do you wish to trust these keys? [ynYN] Y
Enter existing LUKS password:

输入 Y 接受 Tang 服务器的密钥,并提供现有的 LUKS 密码进行初始设置。

通过 systemctl 启用 clevis-luks-askpass.path,以防止非根分区被提示输入密码。

sudo systemctl enable clevis-luks-askpass.path

客户端已经安装完毕。现在,每当你重启服务器时,加密后的磁盘应该会自动解密,并通过 Tang 服务器取回密钥进行挂载。

如果 Tang 服务器因为任何原因不可用,你需要手动提供密码,才能解密和挂载分区。


via: https://opensource.com/article/20/11/nbde-linux

作者:Curt Warfield 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出