Commit | Line | Data |
---|---|---|
0ed3b28a JJ |
1 | /* |
2 | * AppArmor security module | |
3 | * | |
4 | * This file contains AppArmor resource mediation and attachment | |
5 | * | |
6 | * Copyright (C) 1998-2008 Novell/SUSE | |
7 | * Copyright 2009-2010 Canonical Ltd. | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or | |
10 | * modify it under the terms of the GNU General Public License as | |
11 | * published by the Free Software Foundation, version 2 of the | |
12 | * License. | |
13 | */ | |
14 | ||
15 | #include <linux/audit.h> | |
16 | ||
17 | #include "include/audit.h" | |
cf47aede | 18 | #include "include/context.h" |
0ed3b28a JJ |
19 | #include "include/resource.h" |
20 | #include "include/policy.h" | |
21 | ||
22 | /* | |
23 | * Table of rlimit names: we generate it from resource.h. | |
24 | */ | |
25 | #include "rlim_names.h" | |
26 | ||
d384b0a1 KC |
27 | struct aa_fs_entry aa_fs_entry_rlimit[] = { |
28 | AA_FS_FILE_STRING("mask", AA_FS_RLIMIT_MASK), | |
29 | { } | |
30 | }; | |
31 | ||
0ed3b28a JJ |
32 | /* audit callback for resource specific fields */ |
33 | static void audit_cb(struct audit_buffer *ab, void *va) | |
34 | { | |
35 | struct common_audit_data *sa = va; | |
36 | ||
37 | audit_log_format(ab, " rlimit=%s value=%lu", | |
3b3b0e4f | 38 | rlim_names[sa->aad->rlim.rlim], sa->aad->rlim.max); |
0ed3b28a JJ |
39 | } |
40 | ||
41 | /** | |
42 | * audit_resource - audit setting resource limit | |
43 | * @profile: profile being enforced (NOT NULL) | |
44 | * @resoure: rlimit being auditing | |
45 | * @value: value being set | |
46 | * @error: error value | |
47 | * | |
48 | * Returns: 0 or sa->error else other error code on failure | |
49 | */ | |
50 | static int audit_resource(struct aa_profile *profile, unsigned int resource, | |
51 | unsigned long value, int error) | |
52 | { | |
53 | struct common_audit_data sa; | |
3b3b0e4f | 54 | struct apparmor_audit_data aad = {0,}; |
0ed3b28a | 55 | |
50c205f5 | 56 | sa.type = LSM_AUDIT_DATA_NONE; |
3b3b0e4f EP |
57 | sa.aad = &aad; |
58 | aad.op = OP_SETRLIMIT, | |
59 | aad.rlim.rlim = resource; | |
60 | aad.rlim.max = value; | |
61 | aad.error = error; | |
0ed3b28a JJ |
62 | return aa_audit(AUDIT_APPARMOR_AUTO, profile, GFP_KERNEL, &sa, |
63 | audit_cb); | |
64 | } | |
65 | ||
66 | /** | |
67 | * aa_map_resouce - map compiled policy resource to internal # | |
68 | * @resource: flattened policy resource number | |
69 | * | |
70 | * Returns: resource # for the current architecture. | |
71 | * | |
72 | * rlimit resource can vary based on architecture, map the compiled policy | |
73 | * resource # to the internal representation for the architecture. | |
74 | */ | |
75 | int aa_map_resource(int resource) | |
76 | { | |
77 | return rlim_map[resource]; | |
78 | } | |
79 | ||
80 | /** | |
81 | * aa_task_setrlimit - test permission to set an rlimit | |
82 | * @profile - profile confining the task (NOT NULL) | |
3a2dc838 | 83 | * @task - task the resource is being set on |
0ed3b28a JJ |
84 | * @resource - the resource being set |
85 | * @new_rlim - the new resource limit (NOT NULL) | |
86 | * | |
87 | * Control raising the processes hard limit. | |
88 | * | |
89 | * Returns: 0 or error code if setting resource failed | |
90 | */ | |
3a2dc838 JJ |
91 | int aa_task_setrlimit(struct aa_profile *profile, struct task_struct *task, |
92 | unsigned int resource, struct rlimit *new_rlim) | |
0ed3b28a | 93 | { |
cf47aede | 94 | struct aa_profile *task_profile; |
0ed3b28a JJ |
95 | int error = 0; |
96 | ||
cf47aede JJ |
97 | rcu_read_lock(); |
98 | task_profile = aa_get_profile(aa_cred_profile(__task_cred(task))); | |
99 | rcu_read_unlock(); | |
100 | ||
3a2dc838 | 101 | /* TODO: extend resource control to handle other (non current) |
cf47aede JJ |
102 | * profiles. AppArmor rules currently have the implicit assumption |
103 | * that the task is setting the resource of a task confined with | |
104 | * the same profile. | |
3a2dc838 | 105 | */ |
cf47aede | 106 | if (profile != task_profile || |
3a2dc838 JJ |
107 | (profile->rlimits.mask & (1 << resource) && |
108 | new_rlim->rlim_max > profile->rlimits.limits[resource].rlim_max)) | |
109 | error = -EACCES; | |
0ed3b28a | 110 | |
cf47aede JJ |
111 | aa_put_profile(task_profile); |
112 | ||
3a2dc838 | 113 | return audit_resource(profile, resource, new_rlim->rlim_max, error); |
0ed3b28a JJ |
114 | } |
115 | ||
116 | /** | |
117 | * __aa_transition_rlimits - apply new profile rlimits | |
118 | * @old: old profile on task (NOT NULL) | |
119 | * @new: new profile with rlimits to apply (NOT NULL) | |
120 | */ | |
121 | void __aa_transition_rlimits(struct aa_profile *old, struct aa_profile *new) | |
122 | { | |
123 | unsigned int mask = 0; | |
124 | struct rlimit *rlim, *initrlim; | |
125 | int i; | |
126 | ||
127 | /* for any rlimits the profile controlled reset the soft limit | |
128 | * to the less of the tasks hard limit and the init tasks soft limit | |
129 | */ | |
130 | if (old->rlimits.mask) { | |
131 | for (i = 0, mask = 1; i < RLIM_NLIMITS; i++, mask <<= 1) { | |
132 | if (old->rlimits.mask & mask) { | |
133 | rlim = current->signal->rlim + i; | |
134 | initrlim = init_task.signal->rlim + i; | |
135 | rlim->rlim_cur = min(rlim->rlim_max, | |
136 | initrlim->rlim_cur); | |
137 | } | |
138 | } | |
139 | } | |
140 | ||
141 | /* set any new hard limits as dictated by the new profile */ | |
142 | if (!new->rlimits.mask) | |
143 | return; | |
144 | for (i = 0, mask = 1; i < RLIM_NLIMITS; i++, mask <<= 1) { | |
145 | if (!(new->rlimits.mask & mask)) | |
146 | continue; | |
147 | ||
148 | rlim = current->signal->rlim + i; | |
149 | rlim->rlim_max = min(rlim->rlim_max, | |
150 | new->rlimits.limits[i].rlim_max); | |
151 | /* soft limit should not exceed hard limit */ | |
152 | rlim->rlim_cur = min(rlim->rlim_cur, rlim->rlim_max); | |
153 | } | |
154 | } |