xref: /openbmc/linux/security/security.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /*
2  * Security plug functions
3  *
4  * Copyright (C) 2001 WireX Communications, Inc <chris@wirex.com>
5  * Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com>
6  * Copyright (C) 2001 Networks Associates Technology, Inc <ssmalley@nai.com>
7  *
8  *	This program is free software; you can redistribute it and/or modify
9  *	it under the terms of the GNU General Public License as published by
10  *	the Free Software Foundation; either version 2 of the License, or
11  *	(at your option) any later version.
12  */
13 
14 #include <linux/config.h>
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/kernel.h>
18 #include <linux/sched.h>
19 #include <linux/security.h>
20 
21 #define SECURITY_FRAMEWORK_VERSION	"1.0.0"
22 
23 /* things that live in dummy.c */
24 extern struct security_operations dummy_security_ops;
25 extern void security_fixup_ops(struct security_operations *ops);
26 
27 struct security_operations *security_ops;	/* Initialized to NULL */
28 
29 static inline int verify(struct security_operations *ops)
30 {
31 	/* verify the security_operations structure exists */
32 	if (!ops)
33 		return -EINVAL;
34 	security_fixup_ops(ops);
35 	return 0;
36 }
37 
38 static void __init do_security_initcalls(void)
39 {
40 	initcall_t *call;
41 	call = __security_initcall_start;
42 	while (call < __security_initcall_end) {
43 		(*call) ();
44 		call++;
45 	}
46 }
47 
48 /**
49  * security_init - initializes the security framework
50  *
51  * This should be called early in the kernel initialization sequence.
52  */
53 int __init security_init(void)
54 {
55 	printk(KERN_INFO "Security Framework v" SECURITY_FRAMEWORK_VERSION
56 	       " initialized\n");
57 
58 	if (verify(&dummy_security_ops)) {
59 		printk(KERN_ERR "%s could not verify "
60 		       "dummy_security_ops structure.\n", __FUNCTION__);
61 		return -EIO;
62 	}
63 
64 	security_ops = &dummy_security_ops;
65 	do_security_initcalls();
66 
67 	return 0;
68 }
69 
70 /**
71  * register_security - registers a security framework with the kernel
72  * @ops: a pointer to the struct security_options that is to be registered
73  *
74  * This function is to allow a security module to register itself with the
75  * kernel security subsystem.  Some rudimentary checking is done on the @ops
76  * value passed to this function.  A call to unregister_security() should be
77  * done to remove this security_options structure from the kernel.
78  *
79  * If there is already a security module registered with the kernel,
80  * an error will be returned.  Otherwise 0 is returned on success.
81  */
82 int register_security(struct security_operations *ops)
83 {
84 	if (verify(ops)) {
85 		printk(KERN_DEBUG "%s could not verify "
86 		       "security_operations structure.\n", __FUNCTION__);
87 		return -EINVAL;
88 	}
89 
90 	if (security_ops != &dummy_security_ops)
91 		return -EAGAIN;
92 
93 	security_ops = ops;
94 
95 	return 0;
96 }
97 
98 /**
99  * unregister_security - unregisters a security framework with the kernel
100  * @ops: a pointer to the struct security_options that is to be registered
101  *
102  * This function removes a struct security_operations variable that had
103  * previously been registered with a successful call to register_security().
104  *
105  * If @ops does not match the valued previously passed to register_security()
106  * an error is returned.  Otherwise the default security options is set to the
107  * the dummy_security_ops structure, and 0 is returned.
108  */
109 int unregister_security(struct security_operations *ops)
110 {
111 	if (ops != security_ops) {
112 		printk(KERN_INFO "%s: trying to unregister "
113 		       "a security_opts structure that is not "
114 		       "registered, failing.\n", __FUNCTION__);
115 		return -EINVAL;
116 	}
117 
118 	security_ops = &dummy_security_ops;
119 
120 	return 0;
121 }
122 
123 /**
124  * mod_reg_security - allows security modules to be "stacked"
125  * @name: a pointer to a string with the name of the security_options to be registered
126  * @ops: a pointer to the struct security_options that is to be registered
127  *
128  * This function allows security modules to be stacked if the currently loaded
129  * security module allows this to happen.  It passes the @name and @ops to the
130  * register_security function of the currently loaded security module.
131  *
132  * The return value depends on the currently loaded security module, with 0 as
133  * success.
134  */
135 int mod_reg_security(const char *name, struct security_operations *ops)
136 {
137 	if (verify(ops)) {
138 		printk(KERN_INFO "%s could not verify "
139 		       "security operations.\n", __FUNCTION__);
140 		return -EINVAL;
141 	}
142 
143 	if (ops == security_ops) {
144 		printk(KERN_INFO "%s security operations "
145 		       "already registered.\n", __FUNCTION__);
146 		return -EINVAL;
147 	}
148 
149 	return security_ops->register_security(name, ops);
150 }
151 
152 /**
153  * mod_unreg_security - allows a security module registered with mod_reg_security() to be unloaded
154  * @name: a pointer to a string with the name of the security_options to be removed
155  * @ops: a pointer to the struct security_options that is to be removed
156  *
157  * This function allows security modules that have been successfully registered
158  * with a call to mod_reg_security() to be unloaded from the system.
159  * This calls the currently loaded security module's unregister_security() call
160  * with the @name and @ops variables.
161  *
162  * The return value depends on the currently loaded security module, with 0 as
163  * success.
164  */
165 int mod_unreg_security(const char *name, struct security_operations *ops)
166 {
167 	if (ops == security_ops) {
168 		printk(KERN_INFO "%s invalid attempt to unregister "
169 		       " primary security ops.\n", __FUNCTION__);
170 		return -EINVAL;
171 	}
172 
173 	return security_ops->unregister_security(name, ops);
174 }
175 
176 /**
177  * capable - calls the currently loaded security module's capable() function with the specified capability
178  * @cap: the requested capability level.
179  *
180  * This function calls the currently loaded security module's capable()
181  * function with a pointer to the current task and the specified @cap value.
182  *
183  * This allows the security module to implement the capable function call
184  * however it chooses to.
185  */
186 int capable(int cap)
187 {
188 	if (security_ops->capable(current, cap)) {
189 		/* capability denied */
190 		return 0;
191 	}
192 
193 	/* capability granted */
194 	current->flags |= PF_SUPERPRIV;
195 	return 1;
196 }
197 
198 EXPORT_SYMBOL_GPL(register_security);
199 EXPORT_SYMBOL_GPL(unregister_security);
200 EXPORT_SYMBOL_GPL(mod_reg_security);
201 EXPORT_SYMBOL_GPL(mod_unreg_security);
202 EXPORT_SYMBOL(capable);
203 EXPORT_SYMBOL(security_ops);
204