This is a description of the kernel configuration options that relate to security, and an explanation of what they do, and how to use them.
As the kernel controls your computer's networking, it is important that the kernel is very secure, and the kernel itself won't be compromised. To prevent some of the latest networkworking attacks, you should try and keep your kernel version current. You can find new kernels at ftp://ftp.kernel.org
Your terminal servers, or servers with many users, can be further protected by employing Solar Designer's <firstname.lastname@example.org> experimental ``Secure Linux'' kernel patches. As this is still experimental, and not a guaranteed fix, this patch is typically only advisable for hosts with many users, and not servers such as web or email servers. His work states he has done the following:
See the documentation that comes with the software for more information.
Much of the security work being done these days is to prevent someone from ``upgrading'' their normal user privileges, and becomming root. If we could remove that ability entirely, it may help to solve many of the exploits we currently see.
Andrew Morgan has written a series of kernel patches, called Linux-Privs works towards implementing POSIX.1e (formerly POSIX 6) security model under Linux. It is a scheme that more precisely defines device and application permissions. Andrew states, Typically, the user will have to authenticate himself to such an applciation before it will perform its privileged task. This new scheme for system privilege lends itself well to restricting privileged access to the system and reduces the risk of intruders or poorly written applications running amok on the system.
There is an introductory document available at http://www.kernel.org/pub/linux/libs/security/linux-privs/doc/linux-privs.html/linux-privs.html which discusses the features he has implemented, as well an outline for those which still need to be worked on. Some of the available abilities include Access Control Lists (ACL), Mandatory Access Control (MAC), and Kernel-level auditing.
To quote James T. Dennis <email@example.com> in the July 1998, issue of Linux Gazette (available at http://www.ssc.com/lg/)
One approach would be the POSIX.1e ``capabilities'' (which are more like VMS style ``privileges'' than true ``capabilities''). There is a bit of preliminary work being done on this in the 2.1.x kernels --- but nothing is likely be usable in 2.2 (so you're looking at Linux 2.4 before there is "stable" support for any of that).
Another approach is to limit the damage that ``root'' can do using something like the BSD securelevel features. Last I heard on the Linux kernel mailing list they had dropped plans to put in simple ``securelevel'' support in favor of a ``more flexible'' approach --- which would mesh better with the eventual POSIX.1e (``Orange Book'') work.
His discussion is really based on further securing the chroot() function call using ``capabilities'', but has some generally useful descriptions as well. You can find this discussion at http://www.ssc.com/lg/issue30/tag_chroot.html
Briefly, it will allow you to disable access to functions such as mknod(), chroot(), mount(), etc, and move the privileges to the executable itself, rather than simply by being the root user.
There is further information in the Linux kernel 2.1.x sources, as well as the June 25 issue of Linux Weekly News available at http://www.lwn.net/980625/
This option should be enabled. Source routed frames contain the entire path to their destination inside of the packet. This means that routers the packet goes thru does not need to inspect the packet, and just forwards it on. This could lead to data entering your system that may be a potential exploit.
This option is necessary if you are going to configure your machine as a firewall, do masquerading, or wish to protect your dial-up workstation from someone entering via your PPP dial-up interface.
If you enable IP forwarding, your Linux box essentially becomes a router. If your machine is on a network, you could be forwarding data from one network to another, and perhaps subverting a firewall that was put there to prevent this from happening. Normal dial-up users will want to disable this, and other users should concentrate on the security implications of doing this. Firewall machines will want this enabled, and used in conjunction with firewall software.
You can enable and disable IP forwarding dynamically using the following command:
and disable it with the command:
root# echo 1 > /proc/sys/net/ipv4/ip_forward
This file (and many other files in /proc) will always appear to be zero length, but in fact aren't. This is a newly introduced kernel feature, so be sure you are using a kernel 2.0.33 or later.
root# echo 0 > /proc/sys/net/ipv4/ip_forward
This option gives you information about packets your firewall received, like sender, receipient, port, etc.
Generally this option is disabled, but if you are building a firewall or a masquerading host, you will want to enable it. When data is sent from one host to another, it does not always get sent as a single packet of data, but rather it is fragmented into several pieces. The problem with this is that the port numbers are only stored in the first fragment. This means that someone can insert information into the remaining packets for your connection that aren't supposed to be there. It could also prevent a teardrop attack against an internal host that is not yet itself patched against it.
SYN Attack is a denial of service (DoS) attack that consumes all the resources on your machine, forcing you to reboot. We can't think of a reason you wouldn't normally enable this. In the 2.1 kernel series this config option mearly allows syn cookies, but does not enable them. To enable them, you have to do:
root@myhost# echo 1 > /proc/sys/net/ipv4/tcp_syncookies
This is an option that is available in the 2.1 kernel series that will sign NCP packets for stronger security. Normally you can leave it off, but it is there if you do need it.
This is a really neat option that allows you to analyze the first 128 bytes of the packets in a userspace program, to determine if you would like to accept or deny the packet, based on its validity.
There are a few block and character devices available on Linux that will also help you with security.
The two devices
provided by the kernel to retrieve random data at any time.
/dev/urandom should be secure
enough to use in generating PGP keys, SSH challenges, and other
applications where secure random numbers are requisite. Attackers
should be unable to predict the next number given any initial sequence
of numbers from these sources. There has been a lot of effort put in
to ensuring that the numbers you get from these sources are random in
every sense of the word random.
The only difference is that
/dev/random runs out of random
bytes and it makes you wait for more to be accumulated. Note that on
some systems, it can block for a long time waiting for new
user-generated entry to be entered into the system. So you have to
use care before using
/dev/random. (Perhaps the best thing
to do is to use it when you're generating sensitive keying
information, and you tell the user to pound on the keyboard repeatedly
until you print out "OK, enough".)
/dev/random is high quality entropy, generated from measuring
the inter-interrupt times etc. It blocks until enough bits of random
data are available.
/dev/urandom is similar, but when the store of entropy is
running low, it'll return a cryptographically strong hash of what
there is. This isn't as secure, but it's enough for most applications.
You might read from the devices using something like:
user@myhost# head -c 6 /dev/urandom | mmencode
This will print (approximately) six random characters on the console,
suitable for password generation. You can find
(perhaps also known as mimencode on some systems) in the metamail mail
/usr/src/linux/drivers/char/random.c for a description of
Thanks to Theodore Y. Ts'o, Jon Lewis, and others from Linux-kernel for helping me (Dave) with this.