edk2

I don't know where Ars Technica got that from, though. The initial advisory [1] says: > The attacker needs only to deliver a unicast ICMP error message addressed to the client's IP, from any network distance. [1] https://github.com/tianocore/edk2/security/advisories/GHSA-9...

Thank you for sharing this tidbit. It looks like this may have been fixed? https://github.com/tianocore/edk2/blob/master/NetworkPkg/Htt... I have an HTTP netboot flow that worked on older AMI Aptio firmwares, but fails on anything newer to even fetch the bootfile after a successful DHCP cycle, so I heartily agree with your sentiment that these are not necessarily well adjusted clients!

It is increasingly rare for EDK2 (A modern, feature-rich, cross-platform firmware development environment for the UEFI and PI specifications from www.uefi.org: https://github.com/tianocore/edk2) to not be used as the basis for a secure boot load plus runtime firmware services stack). Vendor veerage from vanilla upstream edk2 does occur of course but it does so also with legacy BIOS’. There’s no getting around it in the real world with very very few exceptions. UEFI evolved to solve standardized boot and firmware at scale and the internet as it stands today would struggle without a standard like it. RISC-V taking a different approach would be swimming against the tide backwards to irrelevance.

On the one hand it is good to discover that someone is tackling getting TianoCore working on the Raspberry Pi 5. On the other hand, they still have the destructive backspace behaviour, and inefficient recursive implementation, that breaks the boot loader spinners that the NetBSD and other boot loaders display. It's a tiny thing, but if one is used to the boot sequence the absence of a spinner makes the experience ever so slightly jarring. * https://github.com/NumberOneGit/edk2/blob/master/MdeModulePk... * https://github.com/tianocore/edk2/blob/master/MdeModulePkg/U... * https://tty0.social/@JdeBP/114658278210981731 * https://tty0.social/@JdeBP/114659884938990579

Yes, it is; as I explained back in 2018. It's documented in the IA manuals, and indeed in the AMD manuals. The segment descriptors start off in unreal mode, which is changed at the first far jump that loads CS. TianoCore does a near jump after a couple of NOPs, because there's a whole 64KiB of space for unreal mode code to do the setup for entering the SEC phase, and it does a modicum of setup in unreal mode finding the boot firmware volume and indeed the SEC phase code. u-boot does not take as much advantage of the available space, changing directly from unreal mode to flat model 32-bit protected mode within a few instructions of the initial near jump. * https://news.ycombinator.com/item?id=18166292 * https://github.com/tianocore/edk2/blob/master/UefiCpuPkg/Sec... * https://github.com/tianocore/edk2/blob/master/UefiCpuPkg/Res... * http

I guess I misunderstood your request. This[1] and this[2] should be what you are looking for. [1] https://doc.coreboot.org/security/vboot/index.html [2] https://github.com/tianocore/edk2

Very interesting. I wonder if this a result of some "swiss cheese" effect due to constraints around UEFI and NVRAM themselves, when updating EFI variables. NVRAM must maintain atomicity of memory transactions for power failures. Its whole purpose is to store data when you turn your computer off. As a result, when deleteing an EFI variable, you can't manage the individual bytes - you have to delete a whole entry (which can be rather large - based on the EFI specification and the code used for edk2, e.g. https://github.com/tianocore/edk2/blob/83a86f465ccb1a792f5c5...). Deleting these entries might become a problem when you start running against memory constraints and what slots in memory are actually available; hence a possible fragmentation issue. Additionally, I appreciated how short and specific this blog post was. I enjoy this style of

This is a trace from the BIOS, it is not uncommon to have them printed over the serial console. Potentially the BIOS is based on EDK2 source code, in which case you can take a look here for the implementation of the trace printing logic: https://github.com/tianocore/edk2/blob/9e6537469d4700d9d793e...

For the modern server/desktop and even laptop, that's also no bad thing. It is somewhat ridiculous that UEFI bioses, internally, still boot in 16-bit real mode and have to do all the steps your bios bootloader used to do to set up a 64-bit environment ready to go: https://github.com/tianocore/edk2/blob/edc6681206c1a8791981a..., https://github.com/tianocore/edk2/blob/edc6681206c1a8791981a..., https://github.com/tianocore/edk2/blob/edc6681206c1a8791981a... Why not just start the CPU in "long mode", which is what everyone is using it for, in the first place? These newer ARM processors support 32-bit code at EL0 only (userspace). That seems like a reasonable approach for x86 as well and the freebsd announcement has this to say: > There is currently no plan to remove support for 32-bit binaries on 64-bit kernels. So for the moment, you can run

> I'd quite like UEFI to be able to pass some kind of argv[0] to the direct-loaded kernel, so the kernel knows exactly which file on which partition of which disk it was loaded from. That would then become the default root filesystem. I think UEFI gives an EFI application (such as the Linux kernel) everything it would need for this already - but I guess Linux doesn't use it. The EFI application entry point includes a handle to your own image [0], and the EFI_LOADED_IMAGE_DEVICE_PATH_PROTOCOL_GUID [1] protocol allows you to query the path it was loaded from. It is possible for an image to be loaded without a path, but it looks like EDK2 provides it at least [2]. [0] - https://uefi.org/specs/UEFI/2.10/07_Services_Boot_Services.h... [1] - https://uefi.org/specs/UEFI/2.10/09_Protocols_EFI_Loaded_Ima... [2] - https://github.com/tianocore/edk2

What is the difference between this and https://github.com/tianocore/edk2

No, the specification is not against user freedom. "Always Execute" is not against the spec. "Query User" is partially broken, so it's not even that useful. If you use a bootloader, you will only be able to confirm booting of the bootloader, you won’t be able to confirm the OS that it starts. You will get the dialog, but the input won’t work. MSI did not add any of these features, they are available in EDK II. https://github.com/tianocore/edk2/blob/9ce09870e721efacc41fa...

UEFI is not a big bloat of closed source. UEFI is a spec that defines a newer, more feature-rich and easily-extensible way to boot than legacy BIOS. There is a common core, used by just about every single UEFI-based firmware out there, that is completely open source available here https://github.com/tianocore/edk2 and it's completely possible to ship a fully open UEFI system. It happens to be the case that most organizations using UEFI-based firmware don't, and they keep everything beyond that core closed-source. This is not the fault of UEFI - those companies were closed source beforehand, and that trend continued. UEFI neither caused nor enabled them to be that way. Now you may not want any of the things UEFI brings to the table, like GPT and booting to partitions larger than 2.2TB, or filepath based booting rather than sector based