FilesExpand file tree

 master

/

groups.c

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

239 lines (198 loc) · 4.86 KB

 master

/

groups.c

Copy path

Top

File metadata and controls

• Code
• Blame

239 lines (198 loc) · 4.86 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

/*

* Supplementary group IDs

*/

#include <linux/cred.h>

#include <linux/export.h>

#include <linux/slab.h>

#include <linux/security.h>

#include <linux/sort.h>

#include <linux/syscalls.h>

#include <linux/user_namespace.h>

#include <linux/vmalloc.h>

#include <linux/uaccess.h>

struct group_info *groups_alloc(int gidsetsize)

{

struct group_info *gi;

unsigned int len;

len = sizeof(struct group_info) + sizeof(kgid_t) * gidsetsize;

gi = kmalloc(len, GFP_KERNEL_ACCOUNT|__GFP_NOWARN|__GFP_NORETRY);

if (!gi)

gi = __vmalloc(len, GFP_KERNEL_ACCOUNT, PAGE_KERNEL);

if (!gi)

return NULL;

atomic_set(&gi->usage, 1);

gi->ngroups = gidsetsize;

return gi;

}

EXPORT_SYMBOL(groups_alloc);

void groups_free(struct group_info *group_info)

{

kvfree(group_info);

}

EXPORT_SYMBOL(groups_free);

/* export the group_info to a user-space array */

static int groups_to_user(gid_t __user *grouplist,

const struct group_info *group_info)

{

struct user_namespace *user_ns = current_user_ns();

int i;

unsigned int count = group_info->ngroups;

for (i = 0; i < count; i++) {

gid_t gid;

gid = from_kgid_munged(user_ns, group_info->gid[i]);

if (put_user(gid, grouplist+i))

return -EFAULT;

}

return 0;

}

/* fill a group_info from a user-space array - it must be allocated already */

static int groups_from_user(struct group_info *group_info,

gid_t __user *grouplist)

{

struct user_namespace *user_ns = current_user_ns();

int i;

unsigned int count = group_info->ngroups;

for (i = 0; i < count; i++) {

gid_t gid;

kgid_t kgid;

if (get_user(gid, grouplist+i))

return -EFAULT;

kgid = make_kgid(user_ns, gid);

if (!gid_valid(kgid))

return -EINVAL;

group_info->gid[i] = kgid;

}

return 0;

}

static int gid_cmp(const void *_a, const void *_b)

{

kgid_t a = *(kgid_t *)_a;

kgid_t b = *(kgid_t *)_b;

return gid_gt(a, b) - gid_lt(a, b);

}

static void groups_sort(struct group_info *group_info)

{

sort(group_info->gid, group_info->ngroups, sizeof(*group_info->gid),

gid_cmp, NULL);

}

/* a simple bsearch */

int groups_search(const struct group_info *group_info, kgid_t grp)

{

unsigned int left, right;

if (!group_info)

return 0;

left = 0;

right = group_info->ngroups;

while (left < right) {

unsigned int mid = (left+right)/2;

if (gid_gt(grp, group_info->gid[mid]))

left = mid + 1;

else if (gid_lt(grp, group_info->gid[mid]))

right = mid;

else

return 1;

}

return 0;

}

/**

* set_groups - Change a group subscription in a set of credentials

* @new: The newly prepared set of credentials to alter

* @group_info: The group list to install

*/

void set_groups(struct cred *new, struct group_info *group_info)

{

put_group_info(new->group_info);

groups_sort(group_info);

get_group_info(group_info);

new->group_info = group_info;

}

EXPORT_SYMBOL(set_groups);

/**

* set_current_groups - Change current's group subscription

* @group_info: The group list to impose

*

* Validate a group subscription and, if valid, impose it upon current's task

* security record.

*/

int set_current_groups(struct group_info *group_info)

{

struct cred *new;

new = prepare_creds();

if (!new)

return -ENOMEM;

set_groups(new, group_info);

return commit_creds(new);

}

EXPORT_SYMBOL(set_current_groups);

SYSCALL_DEFINE2(getgroups, int, gidsetsize, gid_t __user *, grouplist)

{

const struct cred *cred = current_cred();

int i;

if (gidsetsize < 0)

return -EINVAL;

/* no need to grab task_lock here; it cannot change */

i = cred->group_info->ngroups;

if (gidsetsize) {

if (i > gidsetsize) {

i = -EINVAL;

goto out;

}

if (groups_to_user(grouplist, cred->group_info)) {

i = -EFAULT;

goto out;

}

}

out:

return i;

}

bool may_setgroups(void)

{

struct user_namespace *user_ns = current_user_ns();

return ns_capable(user_ns, CAP_SETGID) &&

userns_may_setgroups(user_ns);

}

/*

* SMP: Our groups are copy-on-write. We can set them safely

* without another task interfering.

*/

SYSCALL_DEFINE2(setgroups, int, gidsetsize, gid_t __user *, grouplist)

{

struct group_info *group_info;

int retval;

if (!may_setgroups())

return -EPERM;

if ((unsigned)gidsetsize > NGROUPS_MAX)

return -EINVAL;

group_info = groups_alloc(gidsetsize);

if (!group_info)

return -ENOMEM;

retval = groups_from_user(group_info, grouplist);

if (retval) {

put_group_info(group_info);

return retval;

}

retval = set_current_groups(group_info);

put_group_info(group_info);

return retval;

}

/*

* Check whether we're fsgid/egid or in the supplemental group..

*/

int in_group_p(kgid_t grp)

{

const struct cred *cred = current_cred();

int retval = 1;

if (!gid_eq(grp, cred->fsgid))

retval = groups_search(cred->group_info, grp);

return retval;

}

EXPORT_SYMBOL(in_group_p);

int in_egroup_p(kgid_t grp)

{

const struct cred *cred = current_cred();

int retval = 1;

if (!gid_eq(grp, cred->egid))

retval = groups_search(cred->group_info, grp);

return retval;

}

EXPORT_SYMBOL(in_egroup_p);