<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Andras Slemmer on Medium]]></title>
        <description><![CDATA[Stories by Andras Slemmer on Medium]]></description>
        <link>https://medium.com/@exfalso?source=rss-7c08182abb39------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*kqPU3kau_NE_v2DF.</url>
            <title>Stories by Andras Slemmer on Medium</title>
            <link>https://medium.com/@exfalso?source=rss-7c08182abb39------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 06:54:22 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@exfalso/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Swiss cheese to cheddar: securing AMD SEV-SNP early boot]]></title>
            <link>https://medium.com/@exfalso/swiss-cheese-to-cheddar-securing-amd-sev-snp-early-boot-a6560cd33509?source=rss-7c08182abb39------2</link>
            <guid isPermaLink="false">https://medium.com/p/a6560cd33509</guid>
            <category><![CDATA[amd-secure-enclave]]></category>
            <category><![CDATA[amd]]></category>
            <category><![CDATA[confidential-computing]]></category>
            <category><![CDATA[virtualization]]></category>
            <category><![CDATA[information-security]]></category>
            <dc:creator><![CDATA[Andras Slemmer]]></dc:creator>
            <pubDate>Thu, 28 Jul 2022 07:00:48 GMT</pubDate>
            <atom:updated>2022-07-28T10:16:04.850Z</atom:updated>
            <content:encoded><![CDATA[<p>When you press the power button of your computer, a myriad and one hardware and software components spring into action at once. Memory must to be probed, CPU features enumerated, peripherals initialized and operating systems discovered, all before you see those familiar kernel printk log lines appear on the console. This part of the boot process is arcane and legacy-ridden. It is characterized by write-once code that is seldom looked at in the software industry outside of hardware vendors and BIOS authors, even though it is run by virtually every single computer on Earth. It should not be surprising that this is the case: once a piece of x86 assembly was written that initializes the 64bit long-mode of modern Intel CPUs, why would anyone want to change that code, ever?</p><p>Today however, the advent of Confidential Computing and VM-based isolation in particular puts us in an awkward position. Confidential Computing (CC) provides us with never-before seen security guarantees enabling use cases that simply weren’t possible before, however it also assumes an attacker with extreme capabilities. To be precise, the threat model of such technologies is so strong that the hardware, or rather, the hypervisor acting on behalf of the hardware, cannot be trusted anymore! To defend against such a powerful adversary, all we can do is dust off the manuals and rewrite the ancient boot code that has been working fine for so many years.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j8SDbODZZmV5LnB-8WFLmQ.jpeg" /><figcaption>It’s first edition</figcaption></figure><p>All the firmware/BIOS code in use today was written with the assumption that the hardware and the hypervisor are cooperating with the software to orchestrate a successful boot. But with the Confidential Computing attacker model this assumption does not hold anymore. If an attacker can take control of the hypervisor then they can report fake devices, invalid memory locations, even raise exceptions that are completely unrelated to the instruction being executed. Such manipulations open a wide spectrum of attack vectors allowing the attacker to divert the computation’s control flow, and with it compromise all security properties that Confidential Computing is supposed to provide.</p><p>In the following we will describe our journey into the realm of AMD SEV-SNP, the first semi-complete, hardware-isolated and VM-based CC technology to date (although Intel’s TDX is also around the corner). We will explain how we arrived at a hardened VM boot process, starting from a modified version of James Bottomley’s <a href="https://blog.hansenpartnership.com/deploying-encrypted-images-for-confidential-computing/">GRUB/OVMF-based boot method</a>, and ending with a minimal qboot-based firmware that has first-class support of SEV-SNP and crucially, does not rely on <em>any</em> input from the hypervisor (outside of the secure GHCB-based protocol for virtio-vsock). Note that this article is heavily technical and assumes a cursory understanding of how a boot process looks like, as well as basic security concepts. However, we will try to introduce Confidential Computing terminology as we need it.</p><h3>Motivation</h3><p>But first, what is the point of Confidential Computing anyway? You may have heard various buzzwords and slogans around the concept, but the core idea is pretty simple: Confidential Computing gives you a way to prove that a remote machine is doing what you think it’s doing, even if that remote machine has been hacked. The two main properties required for this are</p><ol><li><strong>Isolation</strong>: encryption and integrity checking of memory that the computation is operating on.</li><li><strong>Attestation</strong>: cryptographic signature of hardware vendor proving that the computation has been isolated.</li></ol><p>When you write a piece of Python script and run it locally on your computer, you can be relatively sure that the result you see printed on the screen actually corresponds to the script you have written. This is because you have full control over the machine, and you trust that all software and hardware components that orchestrate the printing of that result are working correctly. Confidential Computing allows you to extend this knowledge to a remote computation.</p><blockquote>We must make a disclaimer here that “Confidential Computing” actually has many definitions, including ones that do not necessitate the use of special hardware. The core idea behind it is this concept of “remotely trustable compute”, and there are also many efforts aiming to implement it with mathematical cryptographic primitives. Hardware-isolation based implementations are also commonly referred to as Trusted Execution Environments or TEEs, and in this article we will be using the two terms synonymously. For a solid introduction on the current TEE landscape, see <a href="https://arxiv.org/pdf/2205.12742.pdf">this article</a>.</blockquote><h3>On the shoulders of SGX</h3><p>The first widely available and mature technology that enables Confidential Computing is Intel’s Software Guard eXtensions. This technology ensures that the data being operated on by the isolated piece of code (the <em>enclave)</em> is never present in plain-text form in DRAM: essentially all data gets encrypted/decrypted as it leaves/enters the CPU package. The hardware also provides integrity and freshness guarantees over said data, so we have the extremely strong confidentiality+integrity+freshness trio on memory as a basic building block. SGX also provides attestation capabilities to prove the isolation property to a remote party: the best way to think about this is as an authenticated Diffie-Hellman key exchange <em>with the SGX-isolated code itself</em>, where attestation = authentication of the isolated code’s hash. Furthermore SGX provides another useful primitive, <em>sealing</em>: this is a key derivation process rooted in per-chip unique entropy, which can be exactly reproduced by a specific enclave even after reboots. With these sealing keys we can persist sensitive data in a durable way, as long as we can retain access to the CPU itself.</p><p>So with SGX we have strong isolation guarantees, attestation capabilities, and encrypted data at rest… why do we need AMD SEV and Intel TDX again? The answer is painfully obvious to anyone who has ever tried to actually use SGX: the programming model. One of SGX’s most appealing properties from a security perspective is also its most appalling one from a usability point of view: the operating system is treated as malicious. In practice this means that any syscall interrupt coming from the isolated code will immediately exit the enclave context. Intel made this choice because syscalls like reading or writing to a file descriptor are inherently unsafe from a Confidential Computing standpoint. The choice of not allowing these calls means that the enclave developer has to be explicit about what data they allow to flow to and from the untrusted part of the software. However, this also means that approximately zero pre-existing applications work inside SGX (and even programming languages, including C because of its widespread dependency on libc), everything must be written from scratch. The lack of syscalls also means that there is no fork(), or any kind of OS-assisted process management capability. SGX effectively gives us <em>process-level</em> single address space isolation, reminiscent of the old DOS days. Good luck running Python FFI code in SGX that runs ld to find a shared object on the filesystem, to be then loaded and executed dynamically...</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/976/1*hCqLe7YH6YcLbxUkzOIkIw.png" /><figcaption>Industry expectations</figcaption></figure><p>Needless to say, this has not exactly helped adoption. There have been various efforts to bridge this usability gap like SCONE, Graphene, Fortanix containers, LKL-SGX and many others. The two main approaches were either to effectively reintroduce syscalls through the enclave-host ABI, or in the case of LKL to completely embed a library OS into the enclave. These approaches are highly involved, have restricted functionality, and in the case of syscall-bridging they (re)introduce a new dimension for attacks. Furthermore, they increase the so called <em>TCB</em> ‘s size. TCB stands for Trusted Computing Base, and it encompasses all software and hardware components that are assumed to be trusted when reasoning about the security of an enclave. A general security design principle is to keep the TCB as small as possible, as the larger it is the harder it becomes to audit and the more potential there is for vulnerabilities.</p><p>Instead of committing to one of these technologies, we decided to bite the bullet and go for the from-scratch approach where we have full control over the security guarantees. (As a side note, this decision resulted in rolling our own distributed SQL engine inside SGX, which perhaps deserves its own article). We knew that a much more usable alternative was around the corner.</p><p>The most natural solution to the usability issue is of course using an already existing abstraction: virtualization (AMD-V/Intel VT-x)! If we could somehow protect a full kernel instead of just a single process, then suddenly everything becomes much easier. There is nothing restricting the compute from making syscalls, as the kernel itself serving those syscalls would be part of the isolated code. One important trade-off that must be mentioned here is that with the inclusion of the operating system the secured code surface (the TCB) is also magnified, which can cause build reproducibility issues and widens the attack surface. Enabling secure virtualization is exactly what AMD and Intel have been tackling for the past years in the forms of SEV and TDX, and what we have been waiting for, as it allows us to enable basically <em>any</em> computation we want.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*LoclON3Shc6YTjnlcEAlvQ.png" /><figcaption>Single process vs virtualization based isolation</figcaption></figure><p>So what about SGX? Is it made obsolete by these VM-based approaches? The answer is no, and in fact Intel’s TDX <a href="https://www.intel.com/content/dam/develop/external/us/en/documents/tdx-whitepaper-v4.pdf"><em>relies</em> on SGX to implement some components</a>. The way to think about it is that SGX simply has different security and usability trade-offs than the VM-based approaches. For example, AMD SEV relies on a separate coprocessor (the PSP) and a custom firmware to <a href="https://www.amd.com/system/files/TechDocs/SEV-SNP-strengthening-vm-isolation-with-integrity-protection-and-more.pdf">implement early encryption, measurement and attestation functionality</a>. This is a new component to attack, and in fact it has been the main focus of <a href="https://arxiv.org/pdf/2108.04575.pdf">SEV-related security research to date</a>. SGX simply does not have such a component. So in general the rule of thumb is: in terms of security SGX is king in the TEE world so it’s the recommended tech if you are writing an application from scratch, but if you want to run pre-existing software then use one of the VM approaches.</p><h3>Dipping the toe: measured boot with GRUB</h3><p>Our first tinkering project that involved AMD SEV-SNP was to explore James Bottomley’s boot approach which utilizes OVMF and GRUB. OVMF is the widely adopted firmware for virtual machines, and has extensive support for UEFI, including the full glory of a rescue shell, a graphical menu, everything boot-related. AMD and Intel have been working on OVMF and QEMU/KVM patches to add support for their respective technologies, so it was a natural starting point.</p><p>The original project by James focused on booting an encrypted operating system, and most of the custom code he added concerned the handling of this encryption key. In our case however, we don’t really care about the encryption of the OS disk. What we do care about is the <em>integrity</em> of the boot process and the OS — that the exact known version of the code has been loaded and the startup has not been tampered with. As long as we have code integrity, protecting the actual code contents doesn’t really matter, as secrets will be provisioned dynamically to encrypted memory once the VM has been attested.</p><p>When you power on a regular bare metal machine, there is a piece of firmware/BIOS installed on the motherboard that is responsible for early initialization and configuration of the machine. As part of this initialization the firmware looks for different devices which may contain an operating system — this can be a disk or e.g. a USB device. The BIOS then looks at the partition table of said devices (MBR or GPT), and figures out whether any of the partitions have the “bootable” flag set. It then selects one of these devices and hands control to the bootloader (like GRUB) installed on the partition. However, when booting a secure VM, we need to modify some of these steps.</p><p>The basis of all security guarantees of CC software is the measurement of the TCB: while the initial code image is loaded into the secure environment, it is hashed, and this hash can later be queried by the software to assert that the right code has been loaded. However, if we simply replicated the regular boot process when launching a secure VM, this measurement would only cover the firmware part itself! The loading of the bootloader and operating system from an external device must also be secured, otherwise we may load malicious software and we would be none the wiser. To this end, instead of loading the bootloader from disk, James burned GRUB into the firmware itself, which means that the measurement of the firmware covered the bootloader as well. However, the operating system itself was still not measured, only encrypted/decrypted. So our first project was to extend this by measuring the OS disk itself that GRUB loads — we added a --hash flag to the chainload GRUB command that causes the chainloaded OS disk to be measured. The GRUB configuration then included this flag with the OS disk hash, which in turn was burned into the firmware, which was in turn what got hashed, so we gained integrity of the loaded operating system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*rcafPxZdpQ7N2OBlLu800Q.png" /><figcaption>The bootloader duplicates a lot of work (and hypervisor communications) that the virtualized firmware already does</figcaption></figure><p>Although this worked fine, we also found that it is very easy to divert the boot control flow. OVMF and GRUB were written with a semi-interactive use-case in mind: they have rescue shells, user input, and they query a lot of things from the hypervisor/hardware: it is ripe with potential exploits. If an attacker can trigger a rescue shell (e.g. by replying to a device probe with a non-existent floppy disk device that returns errors), they basically can take over the “secure” VM completely, and hide malicious behaviour while attestation still checks out. So our biggest takeaway from this project was that we cannot really use GRUB as part of the boot process, and OVMF also seems to have too many features and has not been written defensively against a malicious hypervisor.</p><pre>51,669   kvm:kvm_mmio<br>204,562  kvm:kvm_pio</pre><p>(Will explain later… The suspense is real!)</p><h3>Reducing the attack surface: pure OVMF boot</h3><p>When we learned about the security issue with boot methods utilizing existing software, we raised it during the <a href="https://www.youtube.com/watch?v=xL3rz2-X07I&amp;t=16029s">Linux Plumbers Conference</a> dedicated to confidential VM technology. This raised a lively discussion, but more importantly it marked the beginning of a collaboration that would ultimately produce a hardened boot process for AMD SEV-SNP VMs, which was our goal.</p><p>The first step was to again take OVMF, and initiate a direct boot of Linux without the involvement of a bootloader. To do this we still had to measure the OS, and we decided to go with a “monolithic blob” approach for the kernel measurement: when you launch a VM with e.g. QEMU, you can specify the kernel, the initrd and the kernel cmdline as separate command line arguments. If you do so, QEMU will make these blobs available to the guest firmware using a custom protocol called fw_cfg, which can be used for communication between QEMU and the guest VM. The firmware(e.g. SeaBIOS) can then take these blobs and arrange them in memory to initiate a successful Linux boot. In order to simplify the measurement process, instead of handling these blobs separately we instead baked them into a single kernel image using the kernel config options CONFIG_CMDLINE and CONFIG_INITRAMFS_SOURCE. This way we only needed to check a single hash in the guest (OVMF) when loading the kernel from the hypervisor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Qoug_MfY5P1Z-Ffd.png" /></figure><p>Additionally, we tried to remove as much of the hypervisor-firmware communications and extraneous features from OVMF as possible. This included virtio and disk support (note: virtio would be supported by the launched kernel though), console/shell support, PCI, SCSI and TPM support, suspend/resume, pflash probes and SMBIOS. To eliminate data exchange regarding number of vCPUs and size of memory, we decided to fix these values inside the firmware. In practice this means that the VMs created using this boot method cannot be dynamically sized, the measurement of the VM will cover how many vCPUs and how much memory the VM will use. To facilitate burning in these parameters and also for burning in the loaded kernel’s hash, we added a custom OVMF metadata section to the firmware that contains these values. After building the firmware, the metadata at this specific offset can be modified by a tool to set the parameters as we want (and with it, change the measurement). Furthermore, we minimized the kernel itself by starting from a very small kernel configuration called tinyconfig, and slowly adding features required to boot a minimal system with virtio VSOCK support, and features needed to run our actual payloads. To illustrate, a stock Ubuntu 20.04 LTS distribution from Azure uses 2562 kernel configuration options (=y) and the bzImage is 14MB, whereas a minimal non-debug kernel we use that has support for running docker containers uses 340 options and the bzImage is only 2.9MB.</p><pre>792     kvm:kvm_mmio<br>74,379  kvm:kvm_pio</pre><p>(The numbers are going down.. is that a good thing? 🤔)</p><h3>Back to the drawing board: qboot-based AMD SEV-SNP boot</h3><p>One of the most promising minimal x86 firmware candidates was qboot. It has a very small codebase, supports QEMU’s fw_cfg, and basically directly boots the kernel without doing many extraneous roundtrips to the hypervisor. There are several downsides of this. Qboot only supports a 32bit Linux boot, and we need a 64bit boot as we need to access the C-bit in page attributes, which marks the page shared. This is needed to create a GHCB page which is the SEV way of securely communicating with the hypervisor. Moreover, qboot does not support other AMD SEV concepts like the PVALIDATE routine that validates the protected memory region, or the VC exception handler required for safely handling hypervisor interrupts, which are vital to SEV&#39;s proper functioning. It also doesn&#39;t have crypto primitives like SHA256 which we need in order to measure data coming from the hypervisor. Furthermore, QEMU looks specifically for OVMF metadata to determine how to load the VM into SEV, qboot naturally doesn&#39;t have this metadata.</p><p>To evaluate whether it’s worth investing time into a project exploring qboot, we wanted to get some concrete numbers on how much guest-hypervisor communication we can eliminate by switching to it from OVMF. To this end we used tracepoints in KVM to count IO and MMIO requests during an unmodified qboot boot, and compared it with numbers from our OVMF boot. These are the numbers you’ve been seeing at the end of each subsection, and what we’ve been using during the project as a rough measure of potential attack points during early boot. The tracepoints were counted using perf stat -e kvm:kvm_mmio -e kvm:kvm_pio, and our initial measurements showed that qboot has a much reduced attack surface than OVMF.</p><pre>1,595   kvm:kvm_mmio<br>300     kvm:kvm_pio</pre><p>(Initial measurements of IO and MMIO requests with an unmodified qboot)</p><p>We followed a methodical approach here. First we added OVMF-like metadata to the firmware image to cater for QEMU which is expecting it for SEV support. Then we made qboot boot Linux first in 32bit mode (by default it uses the 16bit entry point), then we made it support a 64bit boot, for which we had to add an early CPUID call to get SEV-specific data to setup the initial page table. Then we added SEV-SNP support, in particular the GHCB protocol utilizing the VC exception handler, and the PVALIDATE routine validating the protected memory range.</p><p>Finally, we instrumented all IN calls returning data from the hypervisor. By hashing and asserting these inputs we could explore what kind of data the firmware is using for the boot, and we could slowly try to either eliminate these inputs, or burn in their measurements so that they cannot be tampered with. All of these calls were using QEMU’s fw_cfg protocol.</p><p>We found the following hypervisor inputs:</p><ul><li><em>SMBIOS</em>: This is data exposed by the BIOS(hypervisor) about the PC, like motherboard and CPU information. We could simply remove this from the code altogether as it’s not strictly needed for a boot.</li><li><em>kernel, kernel cmdline, initrd</em>: This is the operating system itself to be loaded by the firmware. The way we eliminated this input was by burning all of these into the firmware blob itself (so we don’t even need to load it and measure it). The only tricky part here was ensuring that the kernel actually fit the maximum size of the firmware. The kernel we embedded was minimal from the get go, for security purposes we based it on the tinyconfig configuration as explained earlier. But we also had to limit initrd, which is a bit trickier as the workload compute can be a lot larger (think docker image sizes..). We solved this by introducing a second boot stage. The initial stage 1 initrd contains only a statically compiled busybox, and once it starts it loads and measures a stage 2 initrd through virtio VSOCK, which is then mounted and chrooted. This way the final combined firmware fit into less than 4MB, which incidentally also made VM boots very fast.</li><li><em>MPTABLE</em>: data regarding number of vCPUs and related interrupt settings to build the CPU table. To eliminate this input we decided to fix the number of vCPUs during build time and burn this number into the metadata as before. The firmware then uses this number to manually construct the right structures for each vCPU.</li><li><em>e820 map</em>: the memory map that describes what physical memory regions are available to the kernel. We pursued an approach similar to MPTABLE and burned in the size of used guest memory into the metadata, and then used this to manually construct the e820 map.</li><li><em>ACPI table</em>: this is where we get the PCI device tree from, needed by the guest kernel for PCI-based virtio. This input we did not eliminate fully at this point as it is quite elaborate to manually construct these tables. Instead we decided to keep this input and measure the blob with a burned in hash. To make the table blob auditable and reproducible, during the build of the firmware we ran QEMU in simulation(non-KVM) mode, where it produced the exact same table as with KVM, and then used that table to calculate the hash of the expected table. Because of this, QEMU became part of the “audit surface” of the firmware (temporarily, see next section).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zsDwzbfUwqUBE3Qn.png" /></figure><p>By the end of this part of the project we ended up with a working SNP-enlightened firmware capable of booting 64bit Linux, and which only loaded the ACPI table from the hypervisor, and even that input was measured!</p><pre>0       kvm:kvm_mmio<br>49      kvm:kvm_pio</pre><p>(So.. close..)</p><h3>Getting rid of ACPI: microvm-based boot</h3><p>Needless to say, we were not satisfied with this ACPI workaround: running QEMU as part of the build process and burning in the ACPI table’s measurement just felt off and unnecessary. So we went back to the very reason why we need the ACPI table in the first place: it’s to pass the device tree, which in turn was needed because we were using PCI-based virtio.</p><p>There are two implementations of virtio: PCI-based and MMIO-based. QEMU supports both, but with different chipset (“machine”)-types. MMIO-based virtio in particular requires the use of the microvm machine type. This was created as part of the Firecracker project specifically to cater for lightweight VMs in cloud environments with little to no device dependencies. If we could make the firmware work with the microvm machine type, we would not need PCI support at all!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*P8Rcdu-eBrH4rXyx.png" /></figure><p>The only hurdle we had to tackle to make this work was the way QEMU loads the firmware. The currently upstreamed QEMU SEV patches make use of the -pflash argument to pass the firmware blob (this is because the main development effort is around supporting OVMF), which then gets measured by the secure co-processor (PSP) as it’s loaded. However, the microvm machine type has no support for -pflash, instead it relies on -bios to pass the firmware. This meant two things, first that we had to extend QEMU to support loading SEV VMs using -bios (which meant we forked QEMU with a surprisingly small patch). And second, we had to address the fact that -bios loads the firmware pages into ROM, and therefore we cannot use that firmware memory for writes. To address this, we added a relocation routine during early initialization where the firmware code relocates into RAM and jumps into itself.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/483/0*PdmeZVbzcDMirWGS.png" /><figcaption>You don’t often see code like this. ✨ Magic! ✨</figcaption></figure><p>By switching to microvm, not only did we remove the last IN calls, we could also remove all the ACPI and fw_cfg code, reducing the firmware code further.</p><p>But I’ll just let the numbers do the talking:</p><pre>0       kvm:kvm_mmio<br>0       kvm:kvm_pio</pre><p>No input. Zero. Nada. Well, until the kernel starts. Incidentally because the guest does not rely on any input from the hypervisor, this also opens up the possibility of switching to a completely different hypervisor any time we want (as long as that hypervisor supports OVMF-style metadata for SEV).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*ztU1LMGVOUlo2RMx8WWeWg.png" /><figcaption>Coffee slurp. Well done!</figcaption></figure><h3>Conclusion</h3><p>Confidential Computing is here to stay, and it’s maturing by the day. With new VM-isolation based technologies the barrier for entry is being lowered significantly, as we can finally secure existing already-written software without too much trouble. Existing software however has not been written with a malicious host in mind, and we must be diligent in eliminating potential attack vectors that are left over from “pre-CC” days.</p><p>Needless to say, securing the integrity of early boot is only one step in the hardening process. The most complex software in the guest VM is the kernel itself, and securing it requires significant effort not only from Confidential Computing developers, but also from Linux maintainers, as the kind of changes required reach deep into the bowels of kernel code. For now we have taken a conservative approach with the kernel by using an absolutely minimal configuration required to run the specific workloads we want, but even that can be open to potential attacks, and supporting a more fully fledged operating system is a lot more work. There is an <a href="https://www.youtube.com/watch?v=7WSoqPG4zEY">ongoing effort</a> by Intel to harden the Linux kernel for Confidential Computing, which will hopefully gain more and more traction over time.</p><p>In this article we described how we hardened AMD SEV-SNP early boot up to the point of handing control to the Linux kernel. The ideas and design will most likely translate to Intel TDX as well, but that is a future bridge to cross. We are planning to open source this work, together with build tooling to produce a -bios firmware blob and the patched QEMU. If you have any questions, comments or suggestions on the approach we&#39;ve taken and the design, please reach out at <a href="/service/mailto:security@decentriq.com">security@decentriq.com</a>, it&#39;s greatly appreciated.</p><p>Also, if you got to this point and you’re interested in this kind of work or how to secure the higher-level compute workload, <a href="https://join.com/companies/decentriq">we are hiring</a>! At Decentriq we use Confidential Computing to enable highly security and privacy-sensitive compute, enabling cross-company and cross-industry data collaborations that simply weren’t possible before.</p><p>We would like to give special thanks to a certain unnamed individual who engineered the lion’s share of this project. They explicitly asked to remain anonymous, but without them this work would not have been possible.</p><p><em>Originally published at </em><a href="https://blog.decentriq.com/swiss-cheese-to-cheddar-securing-amd-sev-snp-early-boot-2/"><em>https://blog.decentriq.com</em></a><em> on July 28, 2022.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a6560cd33509" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Developer Preview: Java in Intel SGX]]></title>
            <link>https://medium.com/corda/developer-preview-java-in-intel-sgx-8d7127ede826?source=rss-7c08182abb39------2</link>
            <guid isPermaLink="false">https://medium.com/p/8d7127ede826</guid>
            <category><![CDATA[intel]]></category>
            <category><![CDATA[jvm]]></category>
            <category><![CDATA[cryptocurrency]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Andras Slemmer]]></dc:creator>
            <pubDate>Fri, 08 Mar 2019 17:56:17 GMT</pubDate>
            <atom:updated>2019-03-13T14:25:06.501Z</atom:updated>
            <content:encoded><![CDATA[<h3>Developer Preview: Java in Intel® SGX</h3><p>Back in 2017 we at R3 <a href="https://medium.com/corda/corda-and-sgx-a-privacy-update-c1a74354c156">first announced</a> that we are working on a project to bring the JVM to the Intel® SGX platform.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ADuZlLg5iFGsrvVP7pRBvg.jpeg" /></figure><p>Today I have the pleasure of announcing the first official release of our ongoing work to allow the secure execution of JVM bytecode inside Intel SGX. The project’s goal is to provide tooling that enables the development of Intel SGX enclaves in Java, Kotlin, Scala, and more generally in any JVM based language. This first release showcases our progress to date - the basic capability of building and hosting JVM enclaves.</p><h3>What is Intel SGX?</h3><p>Intel Software Guard Extensions(SGX) is an extension to modern Intel CPUs designed to help increase the security of application code and data. It allows running code that operates on cryptographically isolated memory areas inaccessible to the owner of the CPU. Furthermore it provides a way to prove to a remote party that they are indeed communicating with such a protected piece of code. This essentially enables the processing of sensitive data remotely, on untrusted machines. You can learn more in this <a href="https://medium.com/corda/intro-to-sgx-from-http-to-enclaves-1bf38a3bf595">introductory article</a>.</p><h3>How can I access the release?</h3><p>During this developer preview phase, we are gathering feedback from a limited audience. To request an invite please <a href="https://www.corda.net/develop/sgxjvm.html">sign up here</a>.</p><p>However, the documentation is available to everyone, to allow you to get a taste of what using the framework is like, you can <a href="https://docs.corda.net/sgxjvm/">view it here</a>.</p><p>Part of the project is public <a href="https://github.com/corda/sgxjvm-public">on Github</a>, including a simple sample application and documentation.</p><p>Also, <a href="https://cordaledger.slack.com/messages/oblivium-project/">join us on Slack</a>!</p><h3>How does this help developers?</h3><p>Developing code for Intel SGX presents some fundamental challenges. Most of the existing libraries, software stack, debugging tools, and even languages that developers are used to are simply not available in enclaves, for two reasons.</p><ol><li>Intel SGX code cannot make system calls. That’s right, no filesystem access, no networking, no nothing baby! Even memory allocation works differently.</li><li>Enclaves aren’t regular programs. With every enclave comes an untrusted host process that loads the enclave and interfaces with it using a custom Intel SGX-specific ABI. Interactions are restricted through this interface, and for good reason, as this is The Attack Surface of Intel SGX.</li></ol><p>To address these constraints, the Intel SDK provides tools to assist developers writing enclaves in C and C++. The SDK includes a partial libc implementation, and a GDB plugin allowing debugging of an enclave loaded in a special mode. These tools are very helpful, but developers who want the safety and productivity of higher level languages need more.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/889/1*e5bttv8phFYH9L9jAQAaMg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*7PEnxdad5EX_qNXBznFhYg.png" /><figcaption>It is a pretty good knife to be fair</figcaption></figure><p>Faced with these challenges, Intel SGX development has so far consisted of two main approaches.</p><h4>Specialized enclaves written in C/C++</h4><p>These are enclaves written from scratch, for a specific purpose. The upside is that these enclaves are self contained, the programmer has full control over what happens in them.</p><p>The downside is it’s very hard to write such an enclave correctly. The usual caveats of C/C++ about unmanaged memory apply. Programmers must learn a brand new set of tools. Existing libraries will likely not work, or need porting. The resulting enclaves are also inflexible, there’s no hope for e.g. dynamic code loading.</p><p>Furthermore if developers want to make sure their enclaves are <em>actually</em> secure they also need to be well versed in security-sensitive programming. And I am not talking about simply importing the latest version of a crypto library. I’m talking about <a href="https://github.com/signalapp/ContactDiscoveryService/blob/69d33cfd8634fc3b1eb74b71e94cde77abe1a1c6/enclave/src/sabd-enclave.c#L170">oblivious computation</a>. Needless to say, this also increases audit requirements, every enclave must be inspected and audited separately, it is difficult to reuse audits, to “compose” trust. But I’m getting ahead of myself.</p><h4>Embedding of existing programs or containers</h4><p>The other route some projects take is to try and embed <a href="https://github.com/oscarlab/graphene">existing programs</a> and even <a href="https://sconecontainers.github.io/">full containers</a>. This in theory solves the usability problem, however we believe it can undermine the security properties Intel SGX provides.</p><p>The way these projects work is they proxy operating system functionality through the host-enclave boundary, and try to mitigate attacks on a per-functionality basis. However, these pre-existing programs were not written with Intel SGX’s quite severe threat model in mind (a malicious operating system). This means the proxying opens a whole new world of possible side channel attacks! The attack surface increases from a well defined enclave-specific auditable ABI to an unspecified list of proxied system calls that are difficult, nay impossible to audit.</p><h4>Our approach</h4><p>We strive for the happy medium between usability and security. We don’t promise that you will be able to run existing applications unmodified, but by enabling the running of JVM bytecode we make a ton of well-known libraries and tools available for enclave development, and open Intel SGX development to a large portion of the programmer community.</p><p>Furthermore, by embedding a JVM we provide a central control point for implementing security hardening, in the virtual machine itself! For example one of our long term plans is to modify the JIT compiler to automatically make memory accesses oblivious, possibly utilizing Intel TSX. Note that this is a longer term research project and certainly is not part of this initial release.</p><h3>What’s in the box?</h3><p>The 1.0 release includes the basic tooling required to build a JVM-based enclave.</p><ul><li><strong>Partial JVM enclaves</strong>: these are binary blobs containing the embedded JVM, which can be linked together with a JAR to create a full enclave. This process will be transparently done by our build tools.</li><li><strong>General purpose enclave(let) host</strong>: this is a hosting process that loads enclaves that abide by a certain ABI. We creatively named such enclaves <em>enclavelets</em>. The programming model is akin to the webserver(host) vs webapp(enclave) separation, clients create sessions with your enclavelet through the host.</li><li><a href="https://docs.corda.net/sgxjvm/1/sgx-gradle-plugins.html"><strong>Gradle build plugins</strong></a>: these plugins allow the building and testing of JVM-based enclaves, as well as bundling of the enclaves with the host process into a Docker container. Note that usage of Docker is optional, you can run the hosting process directly, or even write your own!</li><li><a href="https://github.com/corda/sgxjvm-public/tree/release-1/samples/rng"><strong>Sample code</strong></a>: a simple RNG enclave that generates signed random numbers, and a CLI tool that can connect to such a hosted enclave.</li><li><strong>Hosting</strong>: We host a publicly accessible production-signed instance of the sample RNG enclave and a nightly debug build as well, for testing. See the <a href="https://docs.corda.net/sgxjvm/1/rng-client.html">documentation</a> on how to connect to these.</li></ul><h3>What’s next?</h3><p>Our next release targets <em>end-to-end encryption </em>and <em>dynamic enclave loading</em>.</p><p>The former is simply a feature missing from the current release. It’s relatively straight-forward to add, but requires care. We have a prototype implementation using SIGMA-I, which is what we will use for this work.</p><p>The latter however, is something special. Embedding the JVM opens up a unique possibility of loading code on the fly! This is not easy. So far we have been working with static enclaves, which means the hosting process knew exactly which enclave and therefore what functionality it was loading. However with dynamic loading this is not true anymore. We need to tackle the issue of <em>malicious enclaves.</em></p><p>In order to do this we can utilize a <a href="https://github.com/corda/corda/tree/46909feef93f824c5328a6881314f906944028f6/djvm">sandbox</a> we have developed, originally meant for a different use case (sandboxing Corda transaction verification). With this sandbox we can bound CPU and memory usage of dynamically loaded code, and restrict its access to a sandbox-controlled API. Using this we can effectively multiplex Intel SGX functionality between dynamically loaded enclaves.</p><p>Dynamic code loading means that a large chunk of the auditing work entailed by Intel SGX can be reused between different enclaves, as the JVM and sandbox will stay the same. The separation also helps focus security research. As vulnerabilities in Intel SGX, the JVM and the sandbox are found, we can harden all functionality at once, as opposed to hardening individual functionality-specific enclaves. Of course the dynamically loaded code still needs auditing, but the more code we can share the better.</p><p>Furthermore, from the infrastructure point of view dynamic code loading allows us to spin up a cluster of completely homogeneous enclaves, AWS Lambda style, and load the required functionality on the fly! Because the owner of the hardware no longer matters, this opens the possibility of a global peer to peer network of machines usable without trust: it’s hard to be more spiritually aligned with the blockchain vision than that.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8d7127ede826" width="1" height="1" alt=""><hr><p><a href="https://medium.com/corda/developer-preview-java-in-intel-sgx-8d7127ede826">Developer Preview: Java in Intel SGX</a> was originally published in <a href="https://medium.com/corda">Corda</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Intro to SGX: from HTTP to enclaves]]></title>
            <link>https://medium.com/corda/intro-to-sgx-from-http-to-enclaves-1bf38a3bf595?source=rss-7c08182abb39------2</link>
            <guid isPermaLink="false">https://medium.com/p/1bf38a3bf595</guid>
            <category><![CDATA[cryptocurrency]]></category>
            <category><![CDATA[intel]]></category>
            <category><![CDATA[crypto]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Andras Slemmer]]></dc:creator>
            <pubDate>Thu, 21 Jun 2018 17:51:26 GMT</pubDate>
            <atom:updated>2018-06-24T21:34:26.139Z</atom:updated>
            <content:encoded><![CDATA[<p>I recently submitted a design for the <a href="https://github.com/corda/corda/blob/master/docs/source/design/sgx-infrastructure/design.md">SGX infrastructure</a> we are building at R3, and another design for the <a href="https://github.com/corda/corda/blob/master/docs/source/design/sgx-integration/design.md">integration of SGX into Corda</a>. Although the primary use case is Corda, we are trying to build an agnostic SGX-in-the-cloud infrastructure. In this blog post, I’d like to give an introduction to the underlying tech.</p><h4>Why should I care?</h4><p>In one sentence: SGX provides a way to offload sensitive data processing to remote untrusted machines.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5sApFiBuoqWEp6dkuCZyYA.jpeg" /><figcaption>Trumpets implied</figcaption></figure><p>It’s not simple to use, it’s not yet hardened by years of constant hammering from users, there are a ton of things we haven’t figured out yet, but the tech itself makes sense and I think it may revolutionize the way we think about privacy and security in the future.</p><p>It does this by providing a way to check what code is running remotely. To quote from <a href="https://medium.com/@kaistinchcombe/decentralized-and-trustless-crypto-paradise-is-actually-a-medieval-hellhole-c1ca122efdec">this great article</a>:</p><blockquote>“Instead of directing resources to the <em>elimination</em> of trust, we should direct our resources to the <em>creation</em> of trust”</blockquote><p>Well, SGX allows us to do just that.</p><h4>Is this like ZKP/homomorphic encryption?</h4><p>Yes, but no. It’s not new crypto magic, although a lot of crypto is involved. It hinges on the hardness of breaking the hardware rather than the hardness of breaking a maths problem. In terms of features SGX is much more powerful than ZKP/homomorphic encryption as it allows running (almost) arbitrary computations, including multiparty ones.</p><h4>I don’t believe you</h4><p>Good. Let me try to convince you.</p><p>The heart of SGX is a process called <em>attestation</em>, which is the establishment of trust in a remotely executing program. To understand how this is done and how it is different to existing technologies it’s instructive to look at HTTP and HTTPS first.</p><p>When you open an HTTP webpage, say http://example-unsafe.com, your browser establishes a TCP connection to the remote server and sends a plain text HTTP request over it. The server then sends a plain text reply. Any intermediate node that the packets pass through can intercept, read or modify the packets. This is called a man-in-the-middle attack, and it allows an attacker to impersonate websites and sniff on traffic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a1ULDJ-AkeUpwV-VRdbdYA.png" /><figcaption>An accurate depiction of pure HTTP</figcaption></figure><p>Furthermore there is no control over how the data is used by the server. This means that as soon as the data leaves the end user’s device it’s completely visible and modifiable all the way through. Not good.</p><p>In order to fix this we have a safer version of HTTP called HTTPS, which inserts a <a href="https://en.wikipedia.org/wiki/Transport_Layer_Security">TLS layer</a> between the TCP and HTTP layers.</p><p>When you open an HTTPS webpage, say https://example-less-unsafe.com/ your browser establishes a TCP connection to the remote server, and use it to start the TLS protocol. During handshake the remote side will send your browser a <a href="https://en.wikipedia.org/wiki/Chain_of_trust">certificate chain</a> which your browser proceeds to verify. First it checks that the root public key in the chain is in the browser’s list of <a href="https://www.chromium.org/Home/chromium-security/root-ca-policy">trusted roots</a>. Then the browser proceeds to check the chain itself, which is a sequence of signatures, one key signing the next, all the way up to the server’s key.</p><p>This process establishes trust in the server key that can now be used to create a shared secret between the client and the server through a process called <a href="https://en.wikipedia.org/wiki/Key_exchange"><em>key exchange</em></a>. This fresh key in turn can be used to encrypt the actual HTTP traffic flowing between your browser and the server.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PDtJZmbkek1uMMg_Xl6u7g.png" /><figcaption>HTTPS</figcaption></figure><p>If none of the involved keys are compromised, this protocol can prevent man-in-the-middle attacks. The certificate check ensures that the remote side is in fact who they claim to be (identity established when the remote side registers their key with a Certificate Authority), and the encryption ensures attackers cannot tamper with the traffic.</p><p>Note however that this process only establishes trust in and secures the <em>connection itself</em>. All the cryptography becomes moot if the entity running https://example-less-unsafe.com decides to reveal the traffic to other parties.</p><p>The issue is that the encrypted traffic must be decrypted within the server process, and the decrypted data is then exposed to all programs running on the server machine. This is completely beyond the control of the client.</p><p>One way to solve this is to put the server side traffic processing into a Hardware Security Module. Such a device offers physical protection against tampering with the data flowing through. This means an HSM can be used to do the cryptography, and perhaps even the processing of sensitive data, as some HSMs allow execution of specially developed software. However, even if we did all this, clients must trust that the website does indeed use these HSMs, there’s no way to verify this claim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oPihFgkwdrOx7tD7oaEb-w.png" /><figcaption>Almost there</figcaption></figure><p>This is where SGX and attestation comes into the picture. SGX is basically a mini HSM sitting in modern Intel CPUs, but it goes one step further. What if during the establishment of trust clients could also verify what <em>code</em> is operating on the other side? What would we need to do this?</p><p>First of all we need a way to identify the code that’s running remotely. For this we can simply hash the server’s executable image. In SGX parlance the executable is called the <em>enclave</em> and the hash is called the <em>measurement</em> or MRENCLAVE.</p><p>Once we identified the code, we need to prove that the remote side is in fact executing it, and not something else.</p><p>In order to do this, SGX CPUs use a burnt in key that’s unique to that specific chip to sign a so called <em>report</em> that the executing enclave produces. The report includes the enclave’s measurement, arbitrary data that the enclave provides (usually a key, or hash of) as well as other data like the microcode version.</p><p>How can we verify that such a signature over a report comes from a genuine Intel chip? We can’t. But Intel can, and this is what their Intel Attestation Service is for. They have a REST API to send such signed reports to, and if the report is valid and signed by a genuine Intel CPU then the IAS will reply with an OK, signed with Intel’s root key.</p><p>So, binary produces report, it’s signed by the CPU, which is signed again by Intel if the CPU key is genuine.</p><blockquote><strong><em>Note</em></strong><em>: this is a simplification, the real protocol is more complex and includes an additional “EPID provisioning” step, the CPU key isn’t used directly.</em></blockquote><p>So, with such a signed report an SGX client can verify that a report is coming from a specific executable. Great!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S5_cpBsGJDcVF9RhQ7RR4w.png" /><figcaption>The loop is closed</figcaption></figure><p>However, this is still not sufficient. Even if the client knows what hash is running on the other side, how can they know that the executable isn’t doing anything funny?</p><p>In order to establish trust in the measurement we need a deterministic mapping from the server’s source code to the measurement. The source code must be made available to the client, and the binary’s build must be made completely reproducible, to the bit level. And even then, the vast majority of users will not look at the source code or reproduce the build! We need some kind of auditing process that produces corresponding signatures which users can in turn trust.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JXtZz7KB0lJSLXOkgHf1Ow.jpeg" /><figcaption>SGX end user approves measurement</figcaption></figure><p>The issue is very similar to smart contract code. How many Bitcoin users checked the script that does the spending check? How about Ethereum contracts? This is a point on SGX I haven’t seen discussed <em>anywhere</em>. I’m thinking it’s because the primary use case Intel had in mind for SGX is DRM and similar tech, where the creator of the enclave and the user of the enclave are one and the same entity. “We wrote the enclave and we trust our programmers, so it’s enough to check that the remote enclave’s measurement matches.”</p><p>However a lot of planned use cases don’t look like this. Take <a href="https://signal.org/blog/private-contact-discovery/">Signal</a> for instance. They developed an enclave to do contact discovery, and even made it <a href="https://github.com/signalapp/ContactDiscoveryService">open source</a>. This is great, but how many app users checked the code?</p><p>The security story of SGX relies on users or people they trust auditing the code and reproducing the measurement. I have some thoughts on how we could do this in a reasonable (and even fun!) way, perhaps in another post.</p><blockquote>The security story of SGX relies on users or people they trust auditing the code and reproducing the measurement</blockquote><p>Anyway. The full reasoning about trust from the client’s perspective goes like this.</p><ol><li>I got an HTTP response from Intel signed with their key, which includes an enclave report. This means the report actually does come from an enclave running on Intel hardware, and this enclave’s measurement is the same as in the report.</li><li>The report contains a public key that the enclave created. I, or someone I trust, audited the source code resulting in the measurement, so I know that the key pair was in fact created by the enclave and the enclave won’t leak the private key. I also trust that the key cannot be extracted from the enclave by malicious attackers because of the various architectural decisions Intel made.</li><li>Furthermore, during auditing, I made sure that any data decrypted by the enclave will only be used for its intended purpose.</li><li>This gives me relative confidence that I can proceed with the key exchange and encryption, the traffic can only be decrypted by the enclave image, and it won’t be leaked elsewhere, not even to the administrator of the server.</li></ol><p>We can also think of this as a modified version of usual certificate chains. The root “Certificate Authority” is Intel, but the signed identities aren’t registered entities like companies, but rather specific pieces of code! How cool is that!</p><h3>Disclaimer</h3><p>The above description is a simplified overview of how SGX works, the actual tech is much more involved.</p><p>When I first started working with SGX a lot of the details seemed very mysterious. No matter which documentation I started reading they were all either way too <a href="https://software.intel.com/en-us/sgx/details">high level</a> or way too <a href="https://www.intel.co.uk/content/www/uk/en/architecture-and-technology/64-ia-32-architectures-software-developer-manual-325462.html">low level</a>, and sometimes even <a href="https://software.intel.com/en-us/articles/intel-software-guard-extensions-remote-attestation-end-to-end-example">both</a>. The tech jargon is heavy. What’s the difference between ISVSVN and CPUSVN? What is an Extended Group ID? What does it mean for an enclave to seal to MRSIGNER?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6CDIlQlgnQQt8jf5SZKYZQ.png" /><figcaption>My favorite table from the Intel reference</figcaption></figure><p>Put simply, the tech is complex. A lot of it is very well documented, the instruction reference being a good example. But some of it is less so. What do the LE, QE, PvE and PCE enclaves do? What’s aesmd for?</p><p>It seems that SGX has many different aspects, but it’s hard to find a simple top-down description. Hopefully this post gave some intuition into the possibilities. In the upcoming posts I’ll try to slowly break down the tech, focusing on the software side of things. I would also like to point interested readers to <a href="https://eprint.iacr.org/2016/086.pdf">this paper</a>, which is an excellent beefy deep dive into SGX.</p><h3>Conclusion</h3><p>SGX opens up the possibility for a user to check precisely what a remote party is doing with their data. It’s still a new tech, there are and will be plenty of issues to overcome, but it will open up a way to give end users unprecedented control.</p><p>In the next post we’ll explore how an enclave is loaded(EINIT), how it can access the CPU keys(EGETKEY), and how these relate to Intel provided enclaves.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1bf38a3bf595" width="1" height="1" alt=""><hr><p><a href="https://medium.com/corda/intro-to-sgx-from-http-to-enclaves-1bf38a3bf595">Intro to SGX: from HTTP to enclaves</a> was originally published in <a href="https://medium.com/corda">Corda</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>