[ObviousScience]

To be honest, I think OpenBSD is ahead on some fronts (research on security mechanisms, for instance), but the reason that I tend to use FreeBSD is that it actually works with software packages.

So the computers are based on FreeBSD (which manages the hypervisor -- and soon container daemon!), and appliances only are based on OpenBSD.

Compatibility ftw.

[noinsight]

> it actually works with software packages.

Well I don't know about that. I can't open Settings in Chromium at all anymore, the whole browser crashes. It also constantly uses 100% CPU for something so with Chromium open my load is always >1.

In VirtualBox none of the file open dialogs work.

If I switch to a console from X the whole screen glitches and gets stuck, I have to SSH in to restart/stop X.

Suspend doesn't work for me.

So yeah, it doesn't work on the desktop as well as Linux does. Haven't had any problems with it as a server though.

[swills]

The Chromium issue was fixed recently. Try updating your Chromium to at least 43.0.2357.132.

The VirtualBox issue is long standing, it's caused by the fact that vbox is setuid. Try this:

env KDE_FORK_SLAVES=1 VirtualBox

[noinsight]

Thanks, that fixed it.

[X-Istence]

There is a bug in the kernel that returns the wrong error message when Chrome/Chromium attempts to get a variable. This will be fixed in 10.2.

See: https://twitter.com/cperciva/status/619969753566744576

[swills]

Oh and about the X thing, do you have a Haswell processor? And are you using the VGA driver for X? I had that, bought a $20 ATI card, works fine now, 3D acceleration in KWM and everything.

[noinsight]

Sandy Bridge actually, i7 2600k. I have an ATI card too, I might try that. Wasn't too sure how well those work on FreeBSD.

[lmm]

I would go with nvidia - they work beautifully on FreeBSD IME.

[scurvy]

This part of this thread reminds me of Linux circa 1997.

[erikarn]

Welcome to a completely volunteer run effort.

[kev009]

Virtualbox - sounds like some kind of ports problem, maybe GTK vs Qt? Works for me on PC-BSD and FreeBSD -CURRENT under KDE.

Suspend/resume should be working pretty well in -CURRENT, unfortunately 11.0 is still a ways out if you want a -RELEASE.

[ams6110]

I use OpenBSD and haven't found software to be an issue. Certainly mainstream stuff such as Chromium, Firefox, LibreOffice, VLC, Evince, Gimp, Inkscape... all works.

[jorgecastillo]

The only piece of software I really miss on OpenBSD is the Android SDK, other than that it has everything I use and it works great. So once again I want to tell everyone reading this, if you haven't tried it and if your hardware is supported I invite you to give OpenBSD a spin.

[noinsight]

I've been looking at OpenBSD but the partitioning setup (fdisk) is off-putting. Why are we counting heads/tracks/cylinders in 2015? Also, the labeling thing is weird but I could live with that.

[gonzo]

> research on security mechanisms, for instance)

Citation(s) requested.

[sydney6]

http://youtu.be/OXS8ljif9b8

Edit: First 5 Minutes De Raadt speaks about Mitigation Techniques in comparison to other OSs, including FBSD. I fear, this is still true in mid-2015..

[oscargrouch]

FreeBSD has a lot more energy and community going for it, improving things, that makes it a better bet in the long run.

In the security area, for instance, there are very good things coming from the TrustedBSD and HardenedBSD branch, getting ported back to FreeBSD.

http://www.trustedbsd.org/

http://hardenedbsd.org/

https://en.wikipedia.org/wiki/FreeBSD#Security

[sydney6]

Can you provide further details or examples of how these two projects did or do improve FreeBSD's Security? I know for example about ASLR in FBSD 11 coming from Shawn Webb et. al. from the HardenedBSD project..

[gonzo]

I seriously doubt that ALSR is coming in FreeBSD 11.

[gonzo]

Canaries and other techniques that leverage volatiles do not prevent an overflow; they just try to cope with the consequences of an overflow which has happened. (This is why they're generally lumped together as "mitigation".) The canary tries to detect the case of an overflow which overwrites the return address in a stack frame. Data Execution Prevention (DEP) takes this idea a step further, it assumes that the return address has been overwritten and followed, and it restricts the areas where execution could jump. ASLR is yet another step further: it "shuffles" the areas where execution is allowed.

More specifically, stack canaries work by modifying every function's prologue and epilogue regions to place and check a value on the stack respectively. As such, if a stack buffer is overwritten during a memory copy operation, the error is noticed before execution returns from the copy function. When this happens, an exception is raised, which is passed back up the exception handler hierarchy until it finally hits the OS's default exception handler. If you can overwrite an existing exception handler structure in the stack, you can make it point to your own code. This is a Structured Exception Handling (SEH) exploit, and it allows you to completely bypass the canary check.

DEP and NX (what OpenBSD calls W^X) mark important structures in memory as non-executable, and force hardware-level exceptions if you try to execute those memory regions. This makes normal stack buffer overflows where you set eip to esp+offset and immediately run your shellcode impossible, because the stack is non-executable. Bypassing DEP and NX requires a trick called Return-Oriented Programming (ROP).

ROP essentially involves finding existing snippets of code from the program (called gadgets) and jumping to them, such that you produce a desired outcome. Since the code is part of legitimate executable memory, DEP and NX don't matter. These gadgets are chained together via the stack, which contains the exploit payload. Each entry in the stack corresponds to the address of the next ROP gadget. Each gadget is in the form of instr1; instr2; instr3; ... instrN; ret, so that the ret will jump to the next address on the stack after executing the instructions, thus chaining the gadgets together. Often additional values have to be placed on the stack in order to successfully complete a chain, due to instructions that would otherwise get in the way.

The trick is to chain these ROPs together in order to call a memory protection function such as VirtualProtect, which is then used to make the stack executable, so your shellcode can run, via an jmp esp or equivalent gadget. Tools like mona (https://github.com/corelan/mona) can be used to generate ROP gadget chains, or to find ROP gadgets.

There are a few ways to bypass ASLR:

Direct RET overwrite - Often processes with ASLR will still load non-ASLR modules, allowing you to just run your shellcode via a jmp.

Partial EIP overwrite - Only overwrite part of EIP, or use a reliable information disclosure in the stack to find what the real EIP should be, then use it to calculate your target. We still need a non-ASLR module for this though.

NOP spray/sled - Create a big block of NOPs to increase chance of jump landing on legit memory. Difficult, but possible even when all modules are ASLR-enabled. This won't work if DEP is switched on.

Bruteforce - If you can try an exploit with a vulnerability that doesn't make the program crash, you can bruteforce 256 different target addresses until it works.

Again, the important theme here is that canaries, DEP and ASLR do not defeat overflows themselves, but target the generic overflow exploit methods which have traditionally been employed. The arms race between attackers and defenders in this space is becoming too specialized and increasingly, misses the point.

Additionally, PIE (required for ASLR) has a negative impact on performance: https://nebelwelt.net/publications/12TRpie/gccPIE-TR120614.p...

Additional reading:

https://www.corelan.be/index.php/2010/06/16/exploit-writing-... https://www.corelan.be/index.php/2009/09/21/exploit-writing-...

Or if you're more academically oriented: http://www.scs.stanford.edu/brop/ http://people.csail.mit.edu/rinard/paper/oakland15.pdf

As feld indirectly points out, Capsicum is a much (much) better technology, because it traps the exploit (in a sandbox).

Capsicum extends file descriptors to include the notion of what you are allowed to do with the file. They already have some limited support for this. If, for example, you specify O_RDONLY to the open() system call, then you will get an error if you try writing to the resulting file descriptor. This is largely advisory: There is nothing stopping you from using fstat() to get the original path, and then opening it in a new mode.

This is where Capsicum enters the picture. After a call to cap_enter(), the program is in capability mode and is not allowed to create any new file descriptors via most of the standard mechanisms.

In particular, system calls like open() and socket() will simply fail. This has the advantage that it's a very simple test to perform and therefore quite easy to get right: Just check one flag and give up if it's cleared.

Capability file descriptors behave just like normal ones. You can pass them to any system call that expects a file descriptor, but you may get an error if you don't have the correct rights. These include read and write permissions—and also a variety of other things.

Edit: Theo seems to be cautiously boarding the capabilities train with tame (https://marc.info/?l=openbsd-tech&m=143725996614627&w=2), introduced today.

But Capsicum, Linux's seccomp-bpf (which Theo describes as 'insane') and OS X's seatbelt are all similar. Gaol (https://github.com/pcwalton/gaol) uses either seccomp-bpf or seatbelt as a backend.

Windows 8 has an equivalent of this, using a "mitigation policy" called ProcessSystemCallDisablePolicy, which is set using SetProcessMitigationPolicy(). Chrome uses this for sandboxing on Windows (https://src.chromium.org/chrome/branches/1312/src/sandbox/wi...) and uses seccomp-bpf on linux.

See also: Solaris' Role-Based Access Control and Privileges models. http://www.c0t0d0s0.org/archives/4075-Less-known-Solaris-fea...

[sydney6]

Thank you very much, Gonzo. This is one of the most insightful comments i have read here on HN.

[gonzo]

You are welcome, and thank you!

[feld]

It's like nobody has ever heard of Capsicum

[sydney6]

I believe capsicum is/will be used for sandboxing sshd, ping and tcpdump. Furthermore i know about Security Appliances making use of it, but that's about it, to be honest.

[feld]

Google uses it extensively. But really, it's the future of security because it's proactive not reactive.

[sydney6]

Anyone interested in a quick introduction to capsicum: https://www.youtube.com/watch?v=GI9PmtF9jdM

[gonzo]

Apple uses it, too.

[tedunangst]

Removal of gets() from libc.

[gonzo]

Thanks, Ted.

[hobarrera]

https://marc.info/?l=openbsd-tech&m=143725996614627&w=2

[gonzo]

As noted below, Theo seems to be cautiously boarding the capabilities train with tame. That said, there appear to be some rather large issues with the implementation as it stands.

[FullyFunctional]

tame(2) seems really ad-hoc. Also, isn't the path checking, like

  strncmp(path, "/tmp/", 5) == 0) {

trivially bypassable with a something like /tmp/../usr/bin ?

[alsetmusic]

https://en.m.wikipedia.org/wiki/Comparison_of_BSD_operating_...