signed binaries support [0/4]
Subsystems (8)
PATCH 1/1 signed binaries support [0/4]
Hi,
We (two students of CS) built a system for signing binaries and verifying them before executing. Our main focus was to implement a way to inhibit execution of suid-binaries, which are not trustworthy (i.e. not signed). Of course this can also be used to grant other access rights, capabilities, etc.
The signature (e.g. HMAC-SHA1 with a shared secret) is stored in extended filesystem attributes (userland-signing-tool provided) [1]. Depending on the outcome of our check (performed during exec) a newly introduced flag in the task_struct is set. To be able to also check libraries, we introduced a similar flag in the vm_area struct. Depending on the state of the flag, the suid/sgid bit on the file is honored or ignored. If a process behaves badly (e.g mapping executable memory writable or loading an untrusted library) it is handled appropriately (killed in our current implementation).
In the current state our code is of course very expermimental and should be handled with care.
We mainly seek comments, suggestions and wisdom before we tackle the more difficult tasks, like proper signatures (public-key-systems, etc.).
regards,
Johannes
[1] http://git.informatik.uni-erlangen.de/?p=ssuid-userland&a=snapshot;h=HEAD
Signature · 3 lines
Johannes Schlumberger Department of Computer Science IV
Martensstrasse 1 D-91058 Erlangen Germany University of Erlangen-Nuremberg
http://wwwcip.informatik.uni-erlangen.de/~spjsschlPATCH 1/1 export xattr_resolve_name_sns [1/4]
From: Johannes Schlumberger <[email protected]>
Makes it possible to get extended attributes for a given inode. We need this for cases where we no longer have the corresponding direntry.
--- fs/xattr.c | 18 ++++++++++++++++++ include/linux/xattr.h | 1 + 2 files changed, 19 insertions(+), 0 deletions(-)
fs/xattr.c +18 -0
@@ -538,6 +538,24 @@ xattr_resolve_name(struct xattr_handler **handlers, const char **name)return handler; } +struct xattr_handler * +xattr_resolve_name_sns (struct xattr_handler **handlers,const char **name) +{ +struct xattr_handler *handler; + +if (!*name) +return NULL ; + +for_each_xattr_handler (handlers, handler) { +const char *n =strcmp_prefix (*name, handler->prefix); +if (n) { + *name = n; +break ; + } + } +return handler; +} +/* * Find the handler for the prefix and dispatch its get() operation. */
include/linux/xattr.h +1 -0
@@ -46,6 +46,7 @@ struct xattr_handler { size_t size, int flags); }; +struct xattr_handler *xattr_resolve_name_sns (struct xattr_handler **,const char **);ssize_t vfs_getxattr (struct dentry *,char *,void *,size_t );ssize_t vfs_listxattr (struct dentry *d,char *list,size_t size);int vfs_setxattr (struct dentry *,char *,void *,size_t ,int );
Signature · 1 line
1.5.2.1
PATCH 1/1 sns: add syscall to check signed state of a process [4/4]
In reply to Johannes SchlumbergerMakes it possible for a userspace process to ask for the trustworthiness of another process.
--- arch/i386/kernel/syscall_table.S | 1 + include/asm-i386/unistd.h | 3 ++- security/sns.c | 15 +++++++++++++++ 3 files changed, 18 insertions(+), 1 deletions(-)
arch/i386/kernel/syscall_table.S +1 -0
@@ -323,3 +323,4 @@ ENTRY(sys_call_table) .long sys_signalfd .long sys_timerfd .long sys_eventfd + .long sys_sns_is_trusted /* 320 */
include/asm-i386/unistd.h +2 -1
@@ -329,10 +329,11 @@#define __NR_signalfd 321#define __NR_timerfd 322#define __NR_eventfd 323 +#define __NR_sns_is_trusted 324#ifdef __KERNEL__ -#define NR_syscalls 324 +#define NR_syscalls 325#define __ARCH_WANT_IPC_PARSE_VERSION#define __ARCH_WANT_OLD_READDIR
security/sns.c +15 -0
@@ -112,3 +112,18 @@ int sns_signature_valid(struct file *file)crypto_free_hash (tfm);return ret; } + +asmlinkage int sys_sns_is_trusted(pid_t p) +{ +struct task_struct *t; +rcu_read_lock (); + t =find_task_by_pid (p); +if (IS_ERR (t)) { +rcu_read_unlock (); +return -EINVAL ; + } + p = t->sns_valid_sig;/*locking needed*/ +rcu_read_unlock (); +return p; +} +EXPORT_SYMBOL_GPL (sys_sns_is_trusted);
Signature · 1 line
1.5.2.1
Re: [PATCH] sns: add syscall to check signed state of a process [4/4]
2007/6/22, Alexander Wuerstlein <[email protected]>:
security/sns.c int sns_signature_valid(struct file *file) · line 121
Quoted 6 lines
security/sns.c +6
-0+asmlinkage int sys_sns_is_trusted(pid_t p) +{ +struct task_struct *t; +rcu_read_lock (); + t =find_task_by_pid (p); +if (IS_ERR (t)) {
Shouldn't it be:
if (!t) {
...?
find_task_by_pid() returns NULL on failure.
Quoted 7 lines
security/sns.c +7
-0+rcu_read_unlock (); +return -EINVAL ; + } + p = t->sns_valid_sig;/*locking needed*/ +rcu_read_unlock (); +return p; +}
Re: [PATCH] sns: add syscall to check signed state of a process [4/4]
Quoted 10 lines · Akinobu Mita
2007/6/22, Alexander Wuerstlein <[email protected]>:
security/sns.c int sns_signature_valid(struct file *file) · line 121
Quoted 6 lines
security/sns.c +6
-0+asmlinkage int sys_sns_is_trusted(pid_t p) +{ +struct task_struct *t; +rcu_read_lock (); + t =find_task_by_pid (p); +if (IS_ERR (t)) {Shouldn't it be:
Quoted 5 lines
if (!t) { ...?
find_task_by_pid()returns NULL on failure.
You seem to be right, the rest of the kernel just does 'if (!t)'. We just used IS_ERR() as the 'check for evil pointers' function.
Ciao,
Alexander Wuerstlein.
Re: [PATCH] sns: add syscall to check signed state of a process [4/4]
Quoted 3 lines · Alexander Wuerstlein
You seem to be right, the rest of the kernel just does 'if (!t)'. We just used
IS_ERR()as the 'check for evil pointers' function.
But NULL is not covered by IS_ERR.
Jan
PATCH 1/1 Check files' signatures before doing suid/sgid [2/4]
In reply to Johannes SchlumbergerModified task_struct to hold a 'signed flag' which is set on exec(), inherited on fork() and checked during exec before giving the new process suid/sgid privileges.
sns.c contains our helper functions to verify the signatures. sns_secret_key.dat contains the 'secret key' which is used for HMAC.
--- fs/exec.c | 19 +++++++- include/linux/Kbuild | 2 + include/linux/sched.h | 3 + include/linux/sns.h | 3 + kernel/fork.c | 6 +++ security/Kconfig | 28 ++++++++++++ security/Makefile | 1 + security/sns.c | 104 +++++++++++++++++++++++++++++++++++++++++++ security/sns_secret_key.dat | 5 ++ 9 files changed, 169 insertions(+), 2 deletions(-) create mode 100644 include/linux/sns.h create mode 100644 security/sns.c create mode 100644 security/sns_secret_key.dat
fs/exec.c +17 -2
@@ -51,6 +51,9 @@#include <linux/cn_proc.h> #include <linux/audit.h> #include <linux/signalfd.h> +#ifdef CONFIG_SNS_SIGNED +#include <linux/sns.h> +#endif #include <asm/uaccess.h> #include <asm/mmu_context.h>
@@ -928,13 +931,21 @@ int prepare_binprm(struct linux_binprm *bprm) mode = inode->i_mode;if (bprm->file->f_op ==NULL )return -EACCES ; +#ifdef CONFIG_SNS_SIGNED +if (mode &S_ISUID ) + current->sns_valid_sig =sns_signature_valid (bprm->file); +#endif bprm->e_uid = current->euid; bprm->e_gid = current->egid;if (!(bprm->file->f_path.mnt->mnt_flags &MNT_NOSUID )) {/* Set-uid? */ -if (mode &S_ISUID ) { +#ifdef CONFIG_SNS_SIGNED_SETUID +if (mode &S_ISUID && current->sns_valid_sig) { +#else +if (mode &S_ISUID ) { +#endif /*SNS_SIGNED_SETUID*/ current->personality &= ~PER_CLEAR_ON_SETID ; bprm->e_uid = inode->i_uid; }
@@ -945,7 +956,11 @@ int prepare_binprm(struct linux_binprm *bprm)* is a candidate for mandatory locking, not a setgid * executable. */ -if ((mode & (S_ISGID |S_IXGRP )) == (S_ISGID |S_IXGRP )) { +#ifdef CONFIG_SNS_SIGNED_SETGID +if ((mode & (S_ISGID |S_IXGRP )) == (S_ISGID |S_IXGRP ) && current->sns_valid_sig) { +#else +if ((mode & (S_ISGID |S_IXGRP )) == (S_ISGID |S_IXGRP )) { +#endif /*SNS_SIGNED_SETGID*/ current->personality &= ~PER_CLEAR_ON_SETID ; bprm->e_gid = inode->i_gid; }
include/linux/Kbuild +2 -0
@@ -159,6 +159,7 @@ header-y += videotext.h header-y += vt.h header-y += wireless.h header-y += x25.h +header-y += sns.h unifdef-y += acct.h unifdef-y += adb.h
@@ -347,5 +348,6 @@ unifdef-y += watchdog.h unifdef-y += wireless.h unifdef-y += xattr.h unifdef-y += xfrm.h +unifdef-y += sns.h objhdr-y += version.h
include/linux/sched.h +3 -0
@@ -1076,6 +1076,9 @@ struct task_struct {#ifdef CONFIG_FAULT_INJECTION int make_it_fail;#endif +#ifdef CONFIG_SNS_SIGNED +int sns_valid_sig; +#endif };static inline pid_t process_group (struct task_struct *tsk)
include/linux/sns.h new file +3 -0
@@ -0,0 +1,3 @@ +#ifdef CONFIG_SNS_SIGNED +int sns_signature_valid (struct file *); +#endif
kernel/fork.c +6 -0
@@ -156,6 +156,9 @@ void __init fork_init(unsigned long mempages) init_task.signal->rlim[RLIMIT_NPROC ].rlim_max = max_threads/2 ; init_task.signal->rlim[RLIMIT_SIGPENDING ] = init_task.signal->rlim[RLIMIT_NPROC ]; +#ifdef CONFIG_SNS_SIGNED + init_task.sns_valid_sig =0 ; +#endif }static struct task_struct *dup_task_struct (struct task_struct *orig)
@@ -182,6 +185,9 @@ static struct task_struct *dup_task_struct(struct task_struct *orig)#ifdef CONFIG_CC_STACKPROTECTOR tsk->stack_canary =get_random_int ();#endif +#ifdef CONFIG_SNS_SIGNED + tsk->sns_valid_sig = orig->sns_valid_sig; +#endif /* One for us, one for whoever does the "release_task()" (usually parent) */ atomic_set (&tsk->usage,2 );
security/Kconfig +28 -0
@@ -4,6 +4,34 @@ menu "Security options" +config SNS_SIGNED + bool "Enable sns-signed binaries (EXPERIMENTAL)" + depends on (EXT2_FS_XATTR || EXT3_FS_XATTR || EXT4DEV_FS_XATTR || REISERFS_FS_XATTR || JFFS2_FS_XATTR || CIFS_XATTR) && (CRYPTO_SHA1 || CRYPTO_HMAC || CRYPTO_MD5) && MMU && EXPERIMENTAL + help + This option turns on sns-signatures of binaries. Requires extended + attributes and cryptographic hashes/HMAC support. HMAC is preferred. + + This will leave your system unusable without proper preparation of + your sbit-files. + + If you don't know exactly what you are doing, answer N. + +config SNS_SIGNED_SETUID + bool "Enables sns-signed binaries mandatory for suid-bits" + depends on SNS_SIGNED + help + Mandates signed binaries for suidbits. + + If you don't know exactly what you are doing, answer N. + +config SNS_SIGNED_SETGID + bool "Enables sns-signed binaries mandatory for sgid-bits" + depends on SNS_SIGNED + help + Mandates signed binaries for sgidbits. + + If you don't know exactly what you are doing, answer N. + config KEYS bool "Enable access key retention support" help
security/Makefile +1 -0
@@ -16,3 +16,4 @@ obj-$(CONFIG_SECURITY) += security.o dummy.o inode.o obj-$(CONFIG_SECURITY_SELINUX) += selinux/built-in.o obj-$(CONFIG_SECURITY_CAPABILITIES) += commoncap.o capability.o obj-$(CONFIG_SECURITY_ROOTPLUG) += commoncap.o root_plug.o +obj-$(CONFIG_SNS_SIGNED) += sns.o
security/sns.c new file +104 -0
104 lines not on this page · raw message
security/sns_secret_key.dat new file +5 -0
@@ -0,0 +1,5 @@ +#define SNS_SECRET_KEY_SIZE 8 +static char sns_secret_key[SNS_SECRET_KEY_SIZE] = + { + 'd', 'e', 'a', 'd', 'b', 'e', 'e', 'f' + };
Signature · 1 line
1.5.2.1
Re: [PATCH] Check files' signatures before doing suid/sgid [2/4]
Quoted 4 lines · Alexander Wuerstlein
Modified
task_structto hold a 'signed flag' which is set onexec(), inherited onfork()and checked during exec before giving the new process suid/sgid privileges.
do you also check the signature of glibc and every other shared library that the app uses (or dlopens)? if not.. the entire exercise is rather pointless...
Re: [PATCH] Check files' signatures before doing suid/sgid [2/4]
Quoted 11 lines · Arjan van de Ven
Quoted 4 lines · Alexander Wuerstlein
Modified
task_structto hold a 'signed flag' which is set onexec(), inherited onfork()and checked during exec before giving the new process suid/sgid privileges.do you also check the signature of glibc and every other shared library that the app uses (or dlopens)? if not.. the entire exercise is rather pointless...
We do check that, that is patch [3/4].
Of course we can only check mmap-ed files, if there is no file like with JIT compilers we are out of luck.
Ciao,
Alexander Wuerstlein.
Re: [PATCH] Check files' signatures before doing suid/sgid [2/4]
Quoted 9 lines · Alexander Wuerstlein
Quoted 8 lines · Arjan van de Ven
Quoted 4 lines · Alexander Wuerstlein
Modified
task_structto hold a 'signed flag' which is set onexec(), inherited onfork()and checked during exec before giving the new process suid/sgid privileges.
Quoted 8 lines
Quoted 3 lines
do you also check the signature of glibc and every other shared library that the app uses (or dlopens)? if not.. the entire exercise is rather pointless...
We do check that, that is patch [3/4].
Of course we can only check mmap-ed files, if there is no file like with JIT compilers we are out of luck.
or if the process uses read() not mmap().
or .. or ...
so if perl is signed and it's the perl script that is setuid, and then it includes other perl libs... that's read() not mmap().
Signature · 2 lines
if you want to mail me at work (you don't), use arjan (at) linux.intel.com Test the interaction between Linux and your BIOS via http://www.linuxfirmwarekit.org
Re: [PATCH] Check files' signatures before doing suid/sgid [2/4]
Quoted 14 lines · Arjan van de Ven
Quoted 13 lines · Alexander Wuerstlein
Quoted 11 lines · Arjan van de Ven
Quoted 4 lines · Alexander Wuerstlein
Modified
task_structto hold a 'signed flag' which is set onexec(), inherited onfork()and checked during exec before giving the new process suid/sgid privileges.do you also check the signature of glibc and every other shared library that the app uses (or dlopens)? if not.. the entire exercise is rather pointless...
Quoted 6 lines
Quoted 4 lines
We do check that, that is patch [3/4].
Of course we can only check mmap-ed files, if there is no file like with JIT compilers we are out of luck.
or if the process uses
read()notmmap().
If a process uses read() it needs some executable and writable memory. We do check for this in mprotect(). There is a problem with the i386-architecture, because it allows execution of any readable page (except with newer processors). But beyond that ugliness of i386, it should not be possible to execute anything without us noticing it (hopefully).
Scripting languages are of course problematic. In the suid-case you could just call anyone insane who wants to use a suid-shellscript. But in other cases one might want signed binaries for, we do have a problem. With java or shell one would need an interpreter/vm which is signed and reasonably trustworthy itself and checks the signature of the shellscript or classfile it executes. The (probably not all too complicated) writing of such an interpreter is left as an exercise to the reader ;)
Ciao,
Alexander Wuerstlein.
Re: [PATCH] Check files' signatures before doing suid/sgid [2/4]
Quoted 20 lines · Alexander Wuerstlein
Quoted 19 lines · Arjan van de Ven
Quoted 17 lines · Alexander Wuerstlein
Quoted 11 lines · Arjan van de Ven
Quoted 4 lines · Alexander Wuerstlein
Modified
task_structto hold a 'signed flag' which is set onexec(), inherited onfork()and checked during exec before giving the new process suid/sgid privileges.do you also check the signature of glibc and every other shared library that the app uses (or dlopens)? if not.. the entire exercise is rather pointless...
We do check that, that is patch [3/4].
Of course we can only check mmap-ed files, if there is no file like with JIT compilers we are out of luck.
Quoted 7 lines
Quoted 1 line
or if the process uses
read()notmmap().If a process uses
read()it needs some executable and writable memory. We do check for this inmprotect(). There is a problem with the i386-architecture, because it allows execution of any readable page (except with newer processors). But beyond that ugliness of i386, it should not be possible to execute anything without us noticing it (hopefully).
welcome to mprotect() where the app can just change the permissions
Signature · 2 lines
if you want to mail me at work (you don't), use arjan (at) linux.intel.com Test the interaction between Linux and your BIOS via http://www.linuxfirmwarekit.org
Re: [PATCH] Check files' signatures before doing suid/sgid [2/4]
Hi,
Quoted 7 lines
Quoted 5 lines
If a process uses
read()it needs some executable and writable memory. We do check for this inmprotect(). There is a problem with the i386-architecture, because it allows execution of any readable page (except with newer processors). But beyond that ugliness of i386, it should not be possible to execute anything without us noticing it (hopefully).welcome to
mprotect()where the app can just change the permissions
We have mprotect covered. If a process tries to mprotect() some pages executable, he had writable before, it is no longer trusted in our current implementation.
We are beginning to feel like poeple do not look at our patches, because we screwed up the msg-id, so our Patches are not visible as one clean thread. Sorry for that.
regards,
Johannes
Signature · 3 lines
Johannes Schlumberger Department of Computer Science IV
Martensstrasse 1 D-91058 Erlangen Germany University of Erlangen-Nuremberg
http://wwwcip.informatik.uni-erlangen.de/~spjsschlRe: [PATCH] Check files' signatures before doing suid/sgid [2/4]
In reply to Alexander WuerstleinQuoted 6 lines · Alexander Wuerstlein
If a process uses
read()it needs some executable and writable memory. We do check for this inmprotect(). There is a problem with the i386-architecture, because it allows execution of any readable page (except with newer processors). But beyond that ugliness of i386, it should not be possible to execute anything without us noticing it (hopefully).
r and x together is not a problem IMHO.
Jan
Re: [PATCH] Check files' signatures before doing suid/sgid [2/4]
Hi,
Quoted 7 lines
Quoted 5 lines
If a process uses
read()it needs some executable and writable memory. We do check for this inmprotect(). There is a problem with the i386-architecture, because it allows execution of any readable page (except with newer processors). But beyond that ugliness of i386, it should not be possible to execute anything without us noticing it (hopefully).r and x together is not a problem IMHO.
It is, if you would want to have rw but can only get rwx. regards,
Johannes
Signature · 3 lines
Johannes Schlumberger Department of Computer Science IV
Martensstrasse 1 D-91058 Erlangen Germany University of Erlangen-Nuremberg
http://wwwcip.informatik.uni-erlangen.de/~spjsschlPATCH 1/1 sns: check related executable memory of binaries [3/4]
In reply to Johannes SchlumbergerFrom: Johannes Schlumberger <[email protected]>
Checks on mmap and mprotect (i.e. libraries) wether they are signed and adjusts the processe's signed flag accordingly.
If a process looses its signed state it gets, in our current design, killed, for it is no longer trustworthy. A process also looses its signed flag if it mprotects any memory as executable.
--- include/linux/mm.h | 3 ++ include/linux/sns.h | 17 +++++++++++ kernel/fork.c | 7 ++++ mm/mmap.c | 79 +++++++++++++++++++++++++++++++++++++++++++++++---- mm/mprotect.c | 30 +++++++++++++++++++ security/Kconfig | 36 +++++++++++++++++++++++ security/sns.c | 10 ++++++ 7 files changed, 176 insertions(+), 6 deletions(-)
include/linux/mm.h +3 -0
@@ -112,6 +112,9 @@ struct vm_area_struct {#ifdef CONFIG_NUMA struct mempolicy *vm_policy;/* NUMA policy for the VMA */ #endif +#ifdef CONFIG_SNS_SIGNED +int sns_valid_sig; +#endif };extern struct kmem_cache *vm_area_cachep;
include/linux/sns.h +17 -0
@@ -1,3 +1,20 @@#ifdef CONFIG_SNS_SIGNED int sns_signature_valid (struct file *); +int sns_signature_becomes_invalid (void ); + +/* +* The following is unfortunately necessary, there does not seem to be a +* common define to find out wether some ominous DSO which somebody +* likes to mmap or mprotect is in fact trustworthy kernel code. +*/ +#ifdef CONFIG_X86 +#define sns_is_gate_vdso (addr, len) (addr==0xffffe000 && len == PAGE_SIZE) +#else +#ifdef CONFIG_IA64 +#define sns_is_gate_vdso (addr, len) (addr==0xffffe000UL && len == PAGE_SIZE) +#else +#define sns_is_gate_vdso (addr, len) 0 +#endif +#endif +#endif
kernel/fork.c +7 -0
@@ -260,6 +260,9 @@ static inline int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm) file = tmp->vm_file;if (file) {struct inode *inode = file->f_path.dentry->d_inode; +#ifdef CONFIG_SNS_SIGNED + tmp->sns_valid_sig = mpnt->sns_valid_sig; +#endif get_file (file);if (tmp->vm_flags &VM_DENYWRITE )atomic_dec (&inode->i_writecount);
@@ -271,6 +274,10 @@ static inline int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)vma_prio_tree_add (tmp, mpnt);flush_dcache_mmap_unlock (file->f_mapping);spin_unlock (&file->f_mapping->i_mmap_lock); +#ifdef CONFIG_SNS_SIGNED + }else { + tmp->sns_valid_sig =0 ; +#endif }/*
mm/mmap.c +73 -6
97 lines not on this page · raw message
mm/mprotect.c +30 -0
@@ -26,6 +26,10 @@#include <asm/cacheflush.h> #include <asm/tlbflush.h> +#ifdef CONFIG_SNS_SIGNED +#include <linux/sns.h> +#endif +static void change_pte_range (struct mm_struct *mm,pmd_t *pmd,unsigned long addr,unsigned long end,pgprot_t newprot,int dirty_accountable)
@@ -289,6 +293,32 @@ sys_mprotect(unsigned long start, size_t len, unsigned long prot)if (error) goto out; +#ifdef CONFIG_SNS_SIGNED +if (!sns_is_gate_vdso (start, len)) { +if ((newflags &VM_EXEC ) && current->sns_valid_sig){ +if ((newflags &VM_WRITE ) ==0 ) { +if (current->sns_valid_sig && vma->vm_file) { + vma->sns_valid_sig =sns_signature_valid (vma->vm_file); + current->sns_valid_sig = vma->sns_valid_sig; +if (!current->sns_valid_sig) +sns_signature_becomes_invalid (); + }else { + vma->sns_valid_sig =0 ; + current->sns_valid_sig =0 ; +sns_signature_becomes_invalid (); + } + }else { + vma->sns_valid_sig =0 ; + current->sns_valid_sig =0 ; +sns_signature_becomes_invalid (); + } + } + }else { +/* always trust kernelspace */ + vma->sns_valid_sig =1 ; + } +#endif + tmp = vma->vm_end;if (tmp > end) tmp = end;
security/Kconfig +36 -0
@@ -32,6 +32,42 @@ config SNS_SIGNED_SETGID If you don't know exactly what you are doing, answer N. +config SNS_BRK_ALLOW_EXEC + bool "Allows the executable bit to be set on brk()-ed memory" + depends on SNS_SIGNED + help + By default the memory a process gets from brk() is executable. + This is undesirable in our situation because it would allow + an evil binary to load unsigned code. + + We can either disable the exec-bit on that area (set this option to + off), which might break some programs, or we can allow the exec bit + but remove the signed status (this option on, next option on), + thereby unsigning any program that does some malloc()... + + Choose your poison. + + On old x86 (without CPU-flag NX to be exact) this option is useless + because every readable page is also executable. This might apply to + some other broken architectures as well. YMMV. + + The default behaviour everybody expects is probably broken + either way. If you do not want any problems or you are + unsure, enable this option (SNS_BREAK_ALLOW_EXEC) and + disable the next one (SNS_BRK_UNSIGN). + + I repeat: Always say Y, unless you are very brave... + +config SNS_BRK_UNSIGN + bool "Unsign process after doing brk()" + depends on SNS_BRK_ALLOW_EXEC + help + Remove signed bit from any process that does brk(). + + See previous option (SNS_BRK_ALLOW_EXEC) for help. + + If unsure say N. + config KEYS bool "Enable access key retention support" help
security/sns.c +10 -0
@@ -33,6 +33,16 @@ static int sns_sig_reader(read_descriptor_t *desc, struct page *page, unsigned lreturn read; } +int sns_signature_becomes_invalid (void ) +{ + current->sns_valid_sig =0 ; +/*no checking necessary because of SEND_SIG_FORCED*/ +force_sig_info (SIGKILL ,SEND_SIG_FORCED , current); +return 0 ;/*Leave the actual killing to the scheduler*/ +/*TODO check if the process has any way left to execute any code*/ +} + +/* * check file signature for setuid */
Signature · 1 line
1.5.2.1
Quoted 1 line · Johannes Schlumberger
Hi,
Hi Johannes,
Quoted 4 lines
We (two students of CS) built a system for signing binaries and verifying them before executing. Our main focus was to implement a way to inhibit execution of suid-binaries, which are not trustworthy (i.e. not signed).
...
doesn't anyone who is able to install a not trustworthy suid-binary already have the priviliges to do anything he wants to without requiring an suid bit?
Quoted 3 lines
regards,
Johannes
...
cu
Adrian
Signature · 4 lines
"Is there not promise of rain?" Ling Tan asked suddenly out
of the darkness. There had been need of rain for many days.
"Only a promise," Lao Er said.
Pearl S. Buck - Dragon SeedQuoted 6 lines · Adrian Bunk
Quoted 1 line · Johannes Schlumberger
Hi,
Hi Johannes,
Quoted 8 lines
Quoted 4 lines
We (two students of CS) built a system for signing binaries and verifying them before executing. Our main focus was to implement a way to inhibit execution of suid-binaries, which are not trustworthy (i.e. not signed).
...doesn't anyone who is able to install a not trustworthy suid-binary already have the priviliges to do anything he wants to without requiring an suid bit?
Yes, quite correct in most cases. But if you have taken control of a computer on of the more common ways to keep the control for some time is the installation of a suid-binary (e.g. as part of a rootkit).
One could also imagine a scenario where an attacker controls some filesystems (on external storage perhaps) where he can of course manipulate the suid bit, but he does not have direct control over the attacked system unless he can execute that file.
Ciao,
Alexander Wuerstlein.
Quoted 12 lines · Alexander Wuerstlein
Quoted 11 lines · Adrian Bunk
Quoted 1 line · Johannes Schlumberger
Hi,
Hi Johannes,
Quoted 4 lines
We (two students of CS) built a system for signing binaries and verifying them before executing. Our main focus was to implement a way to inhibit execution of suid-binaries, which are not trustworthy (i.e. not signed).
...
Quoted 7 lines
Quoted 3 lines
doesn't anyone who is able to install a not trustworthy suid-binary already have the priviliges to do anything he wants to without requiring an suid bit?
Yes, quite correct in most cases. But if you have taken control of a computer on of the more common ways to keep the control for some time is the installation of a suid-binary (e.g. as part of a rootkit).
There are so many ways for manipulating a computer that controlling setuid binaries hardly brings a real security gain.
Quoted 4 lines
One could also imagine a scenario where an attacker controls some filesystems (on external storage perhaps) where he can of course manipulate the suid bit, but he does not have direct control over the attacked system unless he can execute that file.
And unless the filesystem is mounted without nosuid...
Quoted 3 lines
Ciao,
Alexander Wuerstlein.
cu
Adrian
Signature · 4 lines
"Is there not promise of rain?" Ling Tan asked suddenly out
of the darkness. There had been need of rain for many days.
"Only a promise," Lao Er said.
Pearl S. Buck - Dragon SeedQuoted 17 lines · Adrian Bunk
Quoted 16 lines · Alexander Wuerstlein
Quoted 14 lines · Adrian Bunk
Quoted 1 line · Johannes Schlumberger
Hi,
Hi Johannes,
Quoted 4 lines
We (two students of CS) built a system for signing binaries and verifying them before executing. Our main focus was to implement a way to inhibit execution of suid-binaries, which are not trustworthy (i.e. not signed).
...doesn't anyone who is able to install a not trustworthy suid-binary already have the priviliges to do anything he wants to without requiring an suid bit?
Quoted 6 lines
Quoted 3 lines
Yes, quite correct in most cases. But if you have taken control of a computer on of the more common ways to keep the control for some time is the installation of a suid-binary (e.g. as part of a rootkit).
There are so many ways for manipulating a computer that controlling setuid binaries hardly brings a real security gain.
Even if it does not really improve security too much it can be helpful as a part of a larger system. For example around here we use a 'sbit-checker' that basically does a 'find' and 'chmod', which we would be able to replace by this patch.
Also our patch is not solely about suid-binaries, we just implemented suid-checking because it seemed a simple and obvious thing to do. Our real aim was to implement binary signatures, which can be used in numerous security related checks around the kernel. Btw. if you have any good ideas where one could use them, please tell us :)
Ciao,
Alexander Wuerstlein.
Quoted 22 lines · Alexander Wuerstlein
Quoted 21 lines · Adrian Bunk
Quoted 19 lines · Alexander Wuerstlein
Quoted 6 lines · Adrian Bunk
Quoted 1 line · Johannes Schlumberger
Hi,
Hi Johannes,
Quoted 8 lines
Quoted 4 lines
We (two students of CS) built a system for signing binaries and verifying them before executing. Our main focus was to implement a way to inhibit execution of suid-binaries, which are not trustworthy (i.e. not signed).
...doesn't anyone who is able to install a not trustworthy suid-binary already have the priviliges to do anything he wants to without requiring an suid bit?
Yes, quite correct in most cases. But if you have taken control of a computer on of the more common ways to keep the control for some time is the installation of a suid-binary (e.g. as part of a rootkit).
Quoted 7 lines
Quoted 2 lines
There are so many ways for manipulating a computer that controlling setuid binaries hardly brings a real security gain.
Even if it does not really improve security too much it can be helpful as a part of a larger system. For example around here we use a 'sbit-checker' that basically does a 'find' and 'chmod', which we would be able to replace by this patch.
Something that sounds as if it would increase security but doesn't really increase security is actually bad since it gives users a false impression of security.
Quoted 5 lines
Also our patch is not solely about suid-binaries, we just implemented suid-checking because it seemed a simple and obvious thing to do. Our real aim was to implement binary signatures, which can be used in numerous security related checks around the kernel. Btw. if you have any good ideas where one could use them, please tell us :)
Linux systems usually ship and heavily use interpreters like bash, perl or python.
Does writing an ELF loader in perl circumvent everything you want to do?
Quoted 2 lines
Ciao,
Alexander Wuerstlein.
cu
Adrian
Signature · 4 lines
"Is there not promise of rain?" Ling Tan asked suddenly out
of the darkness. There had been need of rain for many days.
"Only a promise," Lao Er said.
Pearl S. Buck - Dragon SeedHi,
Quoted 8 lines
Quoted 4 lines
Even if it does not really improve security too much it can be helpful as a part of a larger system. For example around here we use a 'sbit-checker' that basically does a 'find' and 'chmod', which we would be able to replace by this patch.
Something that sounds as if it would increase security but doesn't really increase security is actually bad since it gives users a false impression of security.
We are aware of the limitations, this approach has. It is not designed to make every bit of executed code trusted, because that what just be the same as before. Everything would be given the same amount of trust.
What we do, is establish a caste of binaries and processes more trusted than the rest, which could be used for special tasks.
Quoted 7 lines
Quoted 5 lines
Also our patch is not solely about suid-binaries, we just implemented suid-checking because it seemed a simple and obvious thing to do. Our real aim was to implement binary signatures, which can be used in numerous security related checks around the kernel. Btw. if you have any good ideas where one could use them, please tell us :)
Does writing an ELF loader in perl circumvent everything you want to do?
No, it does not. We do check any executable pages. regards,
Johannes
Signature · 3 lines
Johannes Schlumberger Department of Computer Science IV
Martensstrasse 1 D-91058 Erlangen Germany University of Erlangen-Nuremberg
http://wwwcip.informatik.uni-erlangen.de/~spjsschlPATCH 1/1 export xattr_resolve_name_sns [1/4]
In reply to Johannes SchlumbergerFrom: Johannes Schlumberger <[email protected]>
Makes it possible to get extended attributes for a given inode. We need this for cases where we no longer have the corresponding direntry.
--- fs/xattr.c | 18 ++++++++++++++++++ include/linux/xattr.h | 1 + 2 files changed, 19 insertions(+), 0 deletions(-)
fs/xattr.c +18 -0
@@ -538,6 +538,24 @@ xattr_resolve_name(struct xattr_handler **handlers, const char **name)return handler; } +struct xattr_handler * +xattr_resolve_name_sns (struct xattr_handler **handlers,const char **name) +{ +struct xattr_handler *handler; + +if (!*name) +return NULL ; + +for_each_xattr_handler (handlers, handler) { +const char *n =strcmp_prefix (*name, handler->prefix); +if (n) { + *name = n; +break ; + } + } +return handler; +} +/* * Find the handler for the prefix and dispatch its get() operation. */
include/linux/xattr.h +1 -0
@@ -46,6 +46,7 @@ struct xattr_handler { size_t size, int flags); }; +struct xattr_handler *xattr_resolve_name_sns (struct xattr_handler **,const char **);ssize_t vfs_getxattr (struct dentry *,char *,void *,size_t );ssize_t vfs_listxattr (struct dentry *d,char *list,size_t size);int vfs_setxattr (struct dentry *,char *,void *,size_t ,int );
Signature · 1 line
1.5.2.1
PATCH 1/1 Check files' signatures before doing suid/sgid [2/4]
In reply to Johannes SchlumbergerModified task_struct to hold a 'signed flag' which is set on exec(), inherited on fork() and checked during exec before giving the new process suid/sgid privileges.
sns.c contains our helper functions to verify the signatures. sns_secret_key.dat contains the 'secret key' which is used for HMAC.
--- fs/exec.c | 19 +++++++- include/linux/Kbuild | 2 + include/linux/sched.h | 3 + include/linux/sns.h | 3 + kernel/fork.c | 6 +++ security/Kconfig | 28 ++++++++++++ security/Makefile | 1 + security/sns.c | 104 +++++++++++++++++++++++++++++++++++++++++++ security/sns_secret_key.dat | 5 ++ 9 files changed, 169 insertions(+), 2 deletions(-) create mode 100644 include/linux/sns.h create mode 100644 security/sns.c create mode 100644 security/sns_secret_key.dat
fs/exec.c +17 -2
@@ -51,6 +51,9 @@#include <linux/cn_proc.h> #include <linux/audit.h> #include <linux/signalfd.h> +#ifdef CONFIG_SNS_SIGNED +#include <linux/sns.h> +#endif #include <asm/uaccess.h> #include <asm/mmu_context.h>
@@ -928,13 +931,21 @@ int prepare_binprm(struct linux_binprm *bprm) mode = inode->i_mode;if (bprm->file->f_op ==NULL )return -EACCES ; +#ifdef CONFIG_SNS_SIGNED +if (mode &S_ISUID ) + current->sns_valid_sig =sns_signature_valid (bprm->file); +#endif bprm->e_uid = current->euid; bprm->e_gid = current->egid;if (!(bprm->file->f_path.mnt->mnt_flags &MNT_NOSUID )) {/* Set-uid? */ -if (mode &S_ISUID ) { +#ifdef CONFIG_SNS_SIGNED_SETUID +if (mode &S_ISUID && current->sns_valid_sig) { +#else +if (mode &S_ISUID ) { +#endif /*SNS_SIGNED_SETUID*/ current->personality &= ~PER_CLEAR_ON_SETID ; bprm->e_uid = inode->i_uid; }
@@ -945,7 +956,11 @@ int prepare_binprm(struct linux_binprm *bprm)* is a candidate for mandatory locking, not a setgid * executable. */ -if ((mode & (S_ISGID |S_IXGRP )) == (S_ISGID |S_IXGRP )) { +#ifdef CONFIG_SNS_SIGNED_SETGID +if ((mode & (S_ISGID |S_IXGRP )) == (S_ISGID |S_IXGRP ) && current->sns_valid_sig) { +#else +if ((mode & (S_ISGID |S_IXGRP )) == (S_ISGID |S_IXGRP )) { +#endif /*SNS_SIGNED_SETGID*/ current->personality &= ~PER_CLEAR_ON_SETID ; bprm->e_gid = inode->i_gid; }
include/linux/Kbuild +2 -0
@@ -159,6 +159,7 @@ header-y += videotext.h header-y += vt.h header-y += wireless.h header-y += x25.h +header-y += sns.h unifdef-y += acct.h unifdef-y += adb.h
@@ -347,5 +348,6 @@ unifdef-y += watchdog.h unifdef-y += wireless.h unifdef-y += xattr.h unifdef-y += xfrm.h +unifdef-y += sns.h objhdr-y += version.h
include/linux/sched.h +3 -0
@@ -1076,6 +1076,9 @@ struct task_struct {#ifdef CONFIG_FAULT_INJECTION int make_it_fail;#endif +#ifdef CONFIG_SNS_SIGNED +int sns_valid_sig; +#endif };static inline pid_t process_group (struct task_struct *tsk)
include/linux/sns.h new file +3 -0
@@ -0,0 +1,3 @@ +#ifdef CONFIG_SNS_SIGNED +int sns_signature_valid (struct file *); +#endif
kernel/fork.c +6 -0
@@ -156,6 +156,9 @@ void __init fork_init(unsigned long mempages) init_task.signal->rlim[RLIMIT_NPROC ].rlim_max = max_threads/2 ; init_task.signal->rlim[RLIMIT_SIGPENDING ] = init_task.signal->rlim[RLIMIT_NPROC ]; +#ifdef CONFIG_SNS_SIGNED + init_task.sns_valid_sig =0 ; +#endif }static struct task_struct *dup_task_struct (struct task_struct *orig)
@@ -182,6 +185,9 @@ static struct task_struct *dup_task_struct(struct task_struct *orig)#ifdef CONFIG_CC_STACKPROTECTOR tsk->stack_canary =get_random_int ();#endif +#ifdef CONFIG_SNS_SIGNED + tsk->sns_valid_sig = orig->sns_valid_sig; +#endif /* One for us, one for whoever does the "release_task()" (usually parent) */ atomic_set (&tsk->usage,2 );
security/Kconfig +28 -0
@@ -4,6 +4,34 @@ menu "Security options" +config SNS_SIGNED + bool "Enable sns-signed binaries (EXPERIMENTAL)" + depends on (EXT2_FS_XATTR || EXT3_FS_XATTR || EXT4DEV_FS_XATTR || REISERFS_FS_XATTR || JFFS2_FS_XATTR || CIFS_XATTR) && (CRYPTO_SHA1 || CRYPTO_HMAC || CRYPTO_MD5) && MMU && EXPERIMENTAL + help + This option turns on sns-signatures of binaries. Requires extended + attributes and cryptographic hashes/HMAC support. HMAC is preferred. + + This will leave your system unusable without proper preparation of + your sbit-files. + + If you don't know exactly what you are doing, answer N. + +config SNS_SIGNED_SETUID + bool "Enables sns-signed binaries mandatory for suid-bits" + depends on SNS_SIGNED + help + Mandates signed binaries for suidbits. + + If you don't know exactly what you are doing, answer N. + +config SNS_SIGNED_SETGID + bool "Enables sns-signed binaries mandatory for sgid-bits" + depends on SNS_SIGNED + help + Mandates signed binaries for sgidbits. + + If you don't know exactly what you are doing, answer N. + config KEYS bool "Enable access key retention support" help
security/Makefile +1 -0
@@ -16,3 +16,4 @@ obj-$(CONFIG_SECURITY) += security.o dummy.o inode.o obj-$(CONFIG_SECURITY_SELINUX) += selinux/built-in.o obj-$(CONFIG_SECURITY_CAPABILITIES) += commoncap.o capability.o obj-$(CONFIG_SECURITY_ROOTPLUG) += commoncap.o root_plug.o +obj-$(CONFIG_SNS_SIGNED) += sns.o
security/sns.c new file +104 -0
104 lines not on this page · raw message
security/sns_secret_key.dat new file +5 -0
@@ -0,0 +1,5 @@ +#define SNS_SECRET_KEY_SIZE 8 +static char sns_secret_key[SNS_SECRET_KEY_SIZE] = + { + 'd', 'e', 'a', 'd', 'b', 'e', 'e', 'f' + };
Signature · 1 line
1.5.2.1
Re: [PATCH] Check files' signatures before doing suid/sgid [2/4]
Hi Alexander, Johannes,
[ Added linux-crypto to Cc: ]
Wow, this is _one_ *intrusive* patchset indeed :-)
But first: Have you checked the digsig project? It's been doing (for some time) what your current patchset proposes -- and it uses public key cryptosystems for the key management, which is decidedly better than using secret-keyed hashes (HMAC, XCBC). Also, digsig aims to protect executable binaries in general, and not just suid / sgid ones.
Second: Can we have some discussion on the security model / threat model / trust model / cryptographic key management scheme of your signing mechanism? [I had read through the [0/4] mail you had sent yesterday, but found no relevant discussion on these aspects there.]
Quoted 1 line
From the patchset, it appears you use a *common* secret key
for _all_ signed binaries, and it is set at kernel build-time itself:
Quoted 1 line · Alexander Wuerstlein
sns_secret_key.dat contains the 'secret key' which is used for HMAC.
Where:
security/sns_secret_key.dat line 5
Quoted 7 lines
security/sns_secret_key.dat new file +5
-0+#define SNS_SECRET_KEY_SIZE 8 +static char sns_secret_key[SNS_SECRET_KEY_SIZE] = + { + 'd', 'e', 'a', 'd', 'b', 'e', 'e', 'f' + };
[ Ok, I won't nitpick as to why does this file look like a header, is #include-d in the C source as a header, but still has a .dat extension :-) ]
Anyway, this is *totally* insecure and broken. Do you realize anybody who lays hands on the kernel image can now _trivially_ extract the should-have-been-a-secret key from it and use it to sign his own binaries?
Satyam
Re: [PATCH] Check files' signatures before doing suid/sgid [2/4]
Quoted 8 lines · Satyam Sharma
Hi Alexander, Johannes,
But first: Have you checked the digsig project? It's been doing (for some time) what your current patchset proposes -- and it uses public key cryptosystems for the key management, which is decidedly better than using secret-keyed hashes (HMAC, XCBC). Also, digsig aims to protect executable binaries in general, and not just suid / sgid ones.
We have not heard about digsig before, thanks for pointing it out. After a short look over the source (correct me if I'm wrong): The most important difference between our project and digsig is that digsig relies on storing signatures inside the ELF file structure. Therefore a handmade binary-loader or just COFF binaries could be used to circumvent digsig. We decided against altering the file itself for that and some other reasons.
The limitation to suid/sgid was only due to a limited amount of time we had for implementing our patch. For the future we are planning further uses like setting capabilities only for signed binaries.
Quoted 5 lines
Second: Can we have some discussion on the security model / threat model / trust model / cryptographic key management scheme of your signing mechanism? [I had read through the [0/4] mail you had sent yesterday, but found no relevant discussion on these aspects there.]
Our scenario was as follows: Usually system administrators rely on cronjobs checking their binaries for unwanted suid-bits. Because of the obvious problems with this (time between cronjobs, performance) we wrote our patch to replace it.
An admin would verify the to-be-installed binaries (e.g. by reading the source, checking the distribution's package signatures), sign them in a central location. He then distributes those signatures along with the installation packages onto his computers. There should only be one key in use at a site the public part of which is compiled into the kernel. Any kind of chain-of-trust should be handled in userspace by signing or not signing with the site-wide key depending on the earlier signatures in the chain.
So far for the initial idea. Perhaps it would be useful to have more than one key or some more complex scheme for obtaining the keys and checking their validity. But as all of this would need to be part of the kernel we decided to rather keep it as simple as possible, anything complex is better and more flexibly done in userspace.
Quoted 7 lines
From the patchset, it appears you use a *common* secret key for _all_ signed binaries, and it is set at kernel build-time itself:
[...]
Anyway, this is *totally* insecure and broken. Do you realize anybody who lays hands on the kernel image can now _trivially_ extract the should-have-been-a-secret key from it and use it to sign his own binaries?
We do realize that this is really really ugly, broken and nasty and nobody would or should ever want to use it for anything but playing around as it is atm. ;)
We only used HMAC because it was already available inside the kernel, for implementing real asymetric cryptography there was simply no time. Of course our next objective is to implement that.
Ciao,
Alexander Wuerstlein.
Re: [PATCH] Check files' signatures before doing suid/sgid [2/4]
Quoted 9 lines · Alexander Wuerstlein
Quoted 7 lines · Satyam Sharma
[...]
But first: Have you checked the digsig project? It's been doing (for some time) what your current patchset proposes -- and it uses public key cryptosystems for the key management, which is decidedly better than using secret-keyed hashes (HMAC, XCBC). Also, digsig aims to protect executable binaries in general, and not just suid / sgid ones.
Quoted 5 lines
We have not heard about digsig before, thanks for pointing it out. After a short look over the source (correct me if I'm wrong): The most important difference between our project and digsig is that digsig relies on storing signatures inside the ELF file structure. Therefore a handmade binary-loader or just COFF binaries could be used to circumvent digsig.
Yes, that's correct.
Quoted 5 lines
We decided against
altering the file itself for that and some other reasons.
The limitation to suid/sgid was only due to a limited amount of time we had for implementing our patch. For the future we are planning further uses like setting capabilities only for signed binaries.
Ok, effectively what you have there is a signature on an entire file stored in one of its extended attributes, so I suspect you could think of few other applications for something like this too.
Quoted 5 lines
Quoted 5 lines
Second: Can we have some discussion on the security model / threat model / trust model / cryptographic key management scheme of your signing mechanism? [I had read through the [0/4] mail you had sent yesterday, but found no relevant discussion on these aspects there.]
Quoted 8 lines
[...]
An admin would verify the to-be-installed binaries (e.g. by reading the source, checking the distribution's package signatures), sign them in a central location. He then distributes those signatures along with the installation packages onto his computers. There should only be one key in use at a site the public part of which is compiled into the kernel. Any kind of chain-of-trust should be handled in userspace by signing or not signing with the site-wide key depending on the earlier signatures in the chain.
Ok, so:
1. Admin is trusted. [ This need not mean the same as: "superuser _account_ is trusted", but let's stay in the real world in for now. ]
2. Signing happens at some central, assumed-to-be-secure location (and say the private key never leaves that central secure location). And let's say the admin *repackages* the packages, this time such that the signed files get the signature-carrying-extended-attributes with them, so the installation automatically copies them correctly. => nothing wrong with this assumption.
3. Kernel verifies signatures at runtime. => kernel is trusted.
4. Public key needs to be *compiled into* the kernel ... so this is not getting into mainline, but fair enough as something site administrators would patch in and build.
5. Chain-of-trust handled in userspace. => userspace is trusted.
Let me know if I got the trust model / key management wrong.
Quoted 5 lines
So far for the initial idea. Perhaps it would be useful to have more than one key or some more complex scheme for obtaining the keys and checking their validity. But as all of this would need to be part of the kernel we decided to rather keep it as simple as possible, anything complex is better and more flexibly done in userspace.
Well, if you're trusting (privileged) userspace already, I'm suddenly not so sure
as to what new is this patchset bringing to the table in the first place ... could
you also describe the attack vectors / threats that you had in mind that get blocked with the proposed scheme?
Quoted 8 lines
Quoted 7 lines
From the patchset, it appears you use a *common* secret key for _all_ signed binaries, and it is set at kernel build-time itself:
[...]
Anyway, this is *totally* insecure and broken. Do you realize anybody who lays hands on the kernel image can now _trivially_ extract the should-have-been-a-secret key from it and use it to sign his own binaries?
Quoted 7 lines
We do realize that this is really really ugly, broken and nasty and nobody would or should ever want to use it for anything but playing around as it is atm. ;)
We only used HMAC because it was already available inside the kernel, for implementing real asymetric cryptography there was simply no time. Of course our next objective is to implement that.
Have a look at modsign (signed kernel modules) project too (just the key management part, specifically the asymmetric crypto and DSA implementation that they've already ported to the kernel). You could also go through the lkml archives for whenever that was proposed for inclusion in mainline ...
Satyam
Re: [PATCH] Check files' signatures before doing suid/sgid [2/4]
Quoted 11 lines · Satyam Sharma
Quoted 8 lines · Alexander Wuerstlein
Quoted 1 line · Satyam Sharma
[...]
We decided against
altering the file itself for that and some other reasons. The limitation to suid/sgid was only due to a limited amount of time we had for
implementing our patch. For the future we are planning further uses like setting capabilities only for signed binaries.
Quoted 3 lines
Ok, effectively what you have there is a signature on an entire file stored in one of its extended attributes, so I suspect you could think of few other applications for something like this too.
Yes, for example one could sign Java's classfiles and employ a special trusted Java VM which checks the signatures before execution. Also, this is a more general case of signing kernel modules (as you mentioned below). There are really numerous applications one could imagine, we just don't really know which ones are practical. We definitely appreciate further ideas on this.
Also the signature-in-ELF can be used complementary to our approach: for example NFS is currently unable to handle real extended attributes (nfs does only posix acls). So for binaries delivered over NFS our approach wouldn't work.
Quoted 13 lines
Ok, so:
1. Admin is trusted. [ This need not mean the same as: "superuser _account_ is trusted", but let's stay in the real world in for now. ]
2. Signing happens at some central, assumed-to-be-secure location (and say the private key never leaves that central secure location). And let's say the admin *repackages* the packages, this time such that the signed files get the signature-carrying-extended-attributes with them, so the installation automatically copies them correctly. => nothing wrong with this assumption.
3. Kernel verifies signatures at runtime. => kernel is trusted.
4. Public key needs to be *compiled into* the kernel ... so this is not getting into mainline, but fair enough as something site administrators would patch in and build.
Correct up to here.
Quoted 1 line
5. Chain-of-trust handled in userspace. => userspace is trusted.
Nope. I unluckily wrote 'userspace' where I should have said something else:
Chain-of-trust is handled in what I would label 'Adminspace' (Where we do the signing as in points 1 and 2). There is a very small number of signatures (in our example one) known to the kernel and only those are trusted, and those are applied to the binaries by the administrator in your point 2. The kernel does and should never rely on userspace to tell it which signatures are trustworthy. Only the administrator may do so by means of the signatures directly compiled into the kernel.
So in short: Chain-of-trust is handled by the administrator in his secure central location.
Quoted 11 lines
Quoted 7 lines
So far for the initial idea. Perhaps it would be useful to have more than one
key or some more complex scheme for obtaining the keys and checking their validity. But as all of this would need to be part of the kernel we decided to
rather keep it as simple as possible, anything complex is better and more flexibly done in userspace.Well, if you're trusting (privileged) userspace already, I'm suddenly not so sure as to what new is this patchset bringing to the table in the first place
...
We do not trust any userspace application, see above.
Quoted 2 lines
could you also describe the attack vectors / threats that you had in mind that get blocked with the proposed scheme?
We focus on attacks where an attacker may alter some executable file, for example by altering a mounted nfs-share, manipulating disk-content by simply pulling a disk, mounting it and writing to it, etc.
This relies on the kernel beeing trustworthy of course, so one would need to take special measures to protect the kernel-image from beeing similarly altered. One (somewhat not-so-secure method) would be supplying kernel images by PXE and forbidding local booting, another measure would be using a TPM and an appropriate bootloader to check the kernel for unwanted modifications.
Quoted 4 lines
Have a look at modsign (signed kernel modules) project too (just the key management part, specifically the asymmetric crypto and DSA implementation that they've already ported to the kernel). You could also go through the lkml archives for whenever that was proposed for inclusion in mainline ...
We already thought about that. Using some existing code is definitely preferable to inventing DSA again :)
Ciao,
Alexander Wuerstlein.
Re: [PATCH] Check files' signatures before doing suid/sgid [2/4]
Quoted 10 lines · Alexander Wuerstlein
[...]
Nope. I unluckily wrote 'userspace' where I should have said something else:
Chain-of-trust is handled in what I would label 'Adminspace' (Where we do the signing as in points 1 and 2). There is a very small number of signatures (in our example one) known to the kernel and only those are trusted, and those are applied to the binaries by the administrator in your point 2. The kernel does and should never rely on userspace to tell it which signatures are trustworthy. Only the administrator may do so by means of the signatures directly compiled into the kernel.
Quoted 2 lines
So in short: Chain-of-trust is handled by the administrator in his secure central location.
Ok, so the "trust chain" you're talking about is simply the decision of the admin to compile-in the (verified and trusted) public keys of known trusted entities into the kernel at build time. That is not really scalable, but I guess you might just as well impose such a restriction for sake of simplicity.
[ I initially thought a scenario where a given binary is signed by an entity whose
corresponding public key is _not_ present in the kernel, but who does possess a signature -- over its name, id and public key -- by another entity whose corresponding public key _is_ built into the kernel). Then at the time of verification there's really no other alternative to *build* the entire chain at the_point of verification_ (in-kernel) itself ... but this obviously introduces huge and
ugly complexities that you'd have a hard time bringing into the kernel :-) That "signature over name, id and public key" could be a _certificate_ (if you care about following standards), and building their chains in-kernel ... well. But if you really want to differentiate between kernel and userspace from security perspective, and want to give such functionality, I don't see any easy way out. ]
Quoted 21 lines
Quoted 11 lines
Quoted 7 lines
So far for the initial idea. Perhaps it would be useful to have more than one
key or some more complex scheme for obtaining the keys and checking their validity. But as all of this would need to be part of the kernel we decided to
rather keep it as simple as possible, anything complex is better and more flexibly done in userspace.Well, if you're trusting (privileged) userspace already, I'm suddenly not so sure as to what new is this patchset bringing to the table in the first place
...We do not trust any userspace application, see above.
Quoted 2 lines
could you also describe the attack vectors / threats that you had in mind that get blocked with the proposed scheme?
We focus on attacks where an attacker may alter some executable file, for example by altering a mounted nfs-share, manipulating disk-content by simply pulling a disk, mounting it and writing to it, etc.
Quoted 5 lines
This relies on the kernel beeing trustworthy of course, so one would need to take special measures to protect the kernel-image from beeing similarly altered. One (somewhat not-so-secure method) would be supplying kernel images by PXE and forbidding local booting, another measure would be using a TPM and an appropriate bootloader to check the kernel for unwanted modifications.
Kernel-userspace differentiation from security perspective is always tricky (so this is why I pointed you to the discussions whenever such stuff, such as asymmetric crypto and modsign etc are proposed to be merged). It's definitely not impossible to compromise a _running_ kernel from privileged userspace, if it really wanted to do so ...
Satyam
Re: [PATCH] Check files' signatures before doing suid/sgid [2/4]
In reply to Alexander WuerstleinQuoted 32 lines · Alexander Wuerstlein
fs/exec.c +3
-0+#ifdef CONFIG_SNS_SIGNED +#include <linux/sns.h> +#endif #include <
asm/uaccess.h>
#include <asm/mmu_context.h>fs/exec.c +9
-1@@ -928,13 +931,21 @@ int prepare_binprm(struct linux_binprm *bprm) mode = inode->i_mode;if (bprm->file->f_op ==NULL )return -EACCES ; +#ifdef CONFIG_SNS_SIGNED +if (mode &S_ISUID ) + current->sns_valid_sig =sns_signature_valid (bprm->file); +#endif bprm->e_uid = current->euid; bprm->e_gid = current->egid;if (!(bprm->file->f_path.mnt->mnt_flags &MNT_NOSUID )) {/* Set-uid? */ -if (mode &S_ISUID ) { +#ifdef CONFIG_SNS_SIGNED_SETUID +if (mode &S_ISUID && current->sns_valid_sig) { +#else +if (mode &S_ISUID ) { +#endif /*SNS_SIGNED_SETUID*/ current->personality &= ~PER_CLEAR_ON_SETID ; bprm->e_uid = inode->i_uid; }@@ -945,7 +956,11 @@ int prepare_binprm(struct linux_binprm *bprm)* is a candidate for mandatory locking, not a setgid * executable.
fs/exec.c int prepare_binprm(struct linux_binprm *bprm) · line 966
Quoted 10 lines
fs/exec.c +5
-1*/ -if ((mode & (S_ISGID |S_IXGRP )) == (S_ISGID |S_IXGRP )) { +#ifdef CONFIG_SNS_SIGNED_SETGID +if ((mode & (S_ISGID |S_IXGRP )) == (S_ISGID |S_IXGRP ) && current->sns_valid_sig) { +#else +if ((mode & (S_ISGID |S_IXGRP )) == (S_ISGID |S_IXGRP )) { +#endif /*SNS_SIGNED_SETGID*/ current->personality &= ~PER_CLEAR_ON_SETID ; bprm->e_gid = inode->i_gid; }
...
That's a lot of unwanted ifdefs!
Jan
PATCH 1/1 sns: check related executable memory of binaries [3/4]
In reply to Johannes SchlumbergerFrom: Johannes Schlumberger <[email protected]>
Checks on mmap and mprotect (i.e. libraries) wether they are signed and adjusts the processe's signed flag accordingly.
If a process looses its signed state it gets, in our current design, killed, for it is no longer trustworthy. A process also looses its signed flag if it mprotects any memory as executable.
--- include/linux/mm.h | 3 ++ include/linux/sns.h | 17 +++++++++++ kernel/fork.c | 7 ++++ mm/mmap.c | 79 +++++++++++++++++++++++++++++++++++++++++++++++---- mm/mprotect.c | 30 +++++++++++++++++++ security/Kconfig | 36 +++++++++++++++++++++++ security/sns.c | 10 ++++++ 7 files changed, 176 insertions(+), 6 deletions(-)
include/linux/mm.h +3 -0
@@ -112,6 +112,9 @@ struct vm_area_struct {#ifdef CONFIG_NUMA struct mempolicy *vm_policy;/* NUMA policy for the VMA */ #endif +#ifdef CONFIG_SNS_SIGNED +int sns_valid_sig; +#endif };extern struct kmem_cache *vm_area_cachep;
include/linux/sns.h +17 -0
@@ -1,3 +1,20 @@#ifdef CONFIG_SNS_SIGNED int sns_signature_valid (struct file *); +int sns_signature_becomes_invalid (void ); + +/* +* The following is unfortunately necessary, there does not seem to be a +* common define to find out wether some ominous DSO which somebody +* likes to mmap or mprotect is in fact trustworthy kernel code. +*/ +#ifdef CONFIG_X86 +#define sns_is_gate_vdso (addr, len) (addr==0xffffe000 && len == PAGE_SIZE) +#else +#ifdef CONFIG_IA64 +#define sns_is_gate_vdso (addr, len) (addr==0xffffe000UL && len == PAGE_SIZE) +#else +#define sns_is_gate_vdso (addr, len) 0 +#endif +#endif +#endif
kernel/fork.c +7 -0
@@ -260,6 +260,9 @@ static inline int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm) file = tmp->vm_file;if (file) {struct inode *inode = file->f_path.dentry->d_inode; +#ifdef CONFIG_SNS_SIGNED + tmp->sns_valid_sig = mpnt->sns_valid_sig; +#endif get_file (file);if (tmp->vm_flags &VM_DENYWRITE )atomic_dec (&inode->i_writecount);
@@ -271,6 +274,10 @@ static inline int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)vma_prio_tree_add (tmp, mpnt);flush_dcache_mmap_unlock (file->f_mapping);spin_unlock (&file->f_mapping->i_mmap_lock); +#ifdef CONFIG_SNS_SIGNED + }else { + tmp->sns_valid_sig =0 ; +#endif }/*
mm/mmap.c +73 -6
97 lines not on this page · raw message
mm/mprotect.c +30 -0
@@ -26,6 +26,10 @@#include <asm/cacheflush.h> #include <asm/tlbflush.h> +#ifdef CONFIG_SNS_SIGNED +#include <linux/sns.h> +#endif +static void change_pte_range (struct mm_struct *mm,pmd_t *pmd,unsigned long addr,unsigned long end,pgprot_t newprot,int dirty_accountable)
@@ -289,6 +293,32 @@ sys_mprotect(unsigned long start, size_t len, unsigned long prot)if (error) goto out; +#ifdef CONFIG_SNS_SIGNED +if (!sns_is_gate_vdso (start, len)) { +if ((newflags &VM_EXEC ) && current->sns_valid_sig){ +if ((newflags &VM_WRITE ) ==0 ) { +if (current->sns_valid_sig && vma->vm_file) { + vma->sns_valid_sig =sns_signature_valid (vma->vm_file); + current->sns_valid_sig = vma->sns_valid_sig; +if (!current->sns_valid_sig) +sns_signature_becomes_invalid (); + }else { + vma->sns_valid_sig =0 ; + current->sns_valid_sig =0 ; +sns_signature_becomes_invalid (); + } + }else { + vma->sns_valid_sig =0 ; + current->sns_valid_sig =0 ; +sns_signature_becomes_invalid (); + } + } + }else { +/* always trust kernelspace */ + vma->sns_valid_sig =1 ; + } +#endif + tmp = vma->vm_end;if (tmp > end) tmp = end;
security/Kconfig +36 -0
@@ -32,6 +32,42 @@ config SNS_SIGNED_SETGID If you don't know exactly what you are doing, answer N. +config SNS_BRK_ALLOW_EXEC + bool "Allows the executable bit to be set on brk()-ed memory" + depends on SNS_SIGNED + help + By default the memory a process gets from brk() is executable. + This is undesirable in our situation because it would allow + an evil binary to load unsigned code. + + We can either disable the exec-bit on that area (set this option to + off), which might break some programs, or we can allow the exec bit + but remove the signed status (this option on, next option on), + thereby unsigning any program that does some malloc()... + + Choose your poison. + + On old x86 (without CPU-flag NX to be exact) this option is useless + because every readable page is also executable. This might apply to + some other broken architectures as well. YMMV. + + The default behaviour everybody expects is probably broken + either way. If you do not want any problems or you are + unsure, enable this option (SNS_BREAK_ALLOW_EXEC) and + disable the next one (SNS_BRK_UNSIGN). + + I repeat: Always say Y, unless you are very brave... + +config SNS_BRK_UNSIGN + bool "Unsign process after doing brk()" + depends on SNS_BRK_ALLOW_EXEC + help + Remove signed bit from any process that does brk(). + + See previous option (SNS_BRK_ALLOW_EXEC) for help. + + If unsure say N. + config KEYS bool "Enable access key retention support" help
security/sns.c +10 -0
@@ -33,6 +33,16 @@ static int sns_sig_reader(read_descriptor_t *desc, struct page *page, unsigned lreturn read; } +int sns_signature_becomes_invalid (void ) +{ + current->sns_valid_sig =0 ; +/*no checking necessary because of SEND_SIG_FORCED*/ +force_sig_info (SIGKILL ,SEND_SIG_FORCED , current); +return 0 ;/*Leave the actual killing to the scheduler*/ +/*TODO check if the process has any way left to execute any code*/ +} + +/* * check file signature for setuid */
Signature · 1 line
1.5.2.1
PATCH 1/1 sns: add syscall to check signed state of a process [4/4]
In reply to Johannes SchlumbergerMakes it possible for a userspace process to ask for the trustworthiness of another process.
--- arch/i386/kernel/syscall_table.S | 1 + include/asm-i386/unistd.h | 3 ++- security/sns.c | 15 +++++++++++++++ 3 files changed, 18 insertions(+), 1 deletions(-)
arch/i386/kernel/syscall_table.S +1 -0
@@ -323,3 +323,4 @@ ENTRY(sys_call_table) .long sys_signalfd .long sys_timerfd .long sys_eventfd + .long sys_sns_is_trusted /* 320 */
include/asm-i386/unistd.h +2 -1
@@ -329,10 +329,11 @@#define __NR_signalfd 321#define __NR_timerfd 322#define __NR_eventfd 323 +#define __NR_sns_is_trusted 324#ifdef __KERNEL__ -#define NR_syscalls 324 +#define NR_syscalls 325#define __ARCH_WANT_IPC_PARSE_VERSION#define __ARCH_WANT_OLD_READDIR
security/sns.c +15 -0
@@ -112,3 +112,18 @@ int sns_signature_valid(struct file *file)crypto_free_hash (tfm);return ret; } + +asmlinkage int sys_sns_is_trusted(pid_t p) +{ +struct task_struct *t; +rcu_read_lock (); + t =find_task_by_pid (p); +if (IS_ERR (t)) { +rcu_read_unlock (); +return -EINVAL ; + } + p = t->sns_valid_sig;/*locking needed*/ +rcu_read_unlock (); +return p; +} +EXPORT_SYMBOL_GPL (sys_sns_is_trusted);
Signature · 1 line
1.5.2.1