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
|
/*
* Copyright (c) 2000 Wichert Akkerman <wakkerma@debian.org>
* Copyright (c) 2011 Denys Vlasenko <dvlasenk@redhat.com>
* Copyright (c) 2005-2015 Dmitry V. Levin <ldv@strace.io>
* Copyright (c) 2014-2020 The strace developers.
* All rights reserved.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
#include "defs.h"
/* these constants are the same as in <linux/capability.h> */
enum {
#include "caps0.h"
};
#include "xlat/cap_mask0.h"
/* these constants are CAP_TO_INDEX'ed constants from <linux/capability.h> */
enum {
#include "caps1.h"
};
#include "xlat/cap_mask1.h"
/* these constants are the same as in <linux/capability.h> */
enum {
_LINUX_CAPABILITY_VERSION_1 = 0x19980330,
_LINUX_CAPABILITY_VERSION_2 = 0x20071026,
_LINUX_CAPABILITY_VERSION_3 = 0x20080522
};
#include "xlat/cap_version.h"
struct user_cap_header_struct {
uint32_t version;
int pid;
};
struct user_cap_data_struct {
uint32_t effective;
uint32_t permitted;
uint32_t inheritable;
};
static const struct user_cap_header_struct *
get_cap_header(struct tcb *const tcp, const kernel_ulong_t addr)
{
static struct user_cap_header_struct header;
if (!addr || !verbose(tcp))
return NULL;
if (umove(tcp, addr, &header) < 0)
return NULL;
return &header;
}
static void
print_cap_header(struct tcb *const tcp, const kernel_ulong_t addr,
const struct user_cap_header_struct *const h)
{
if (!addr || !h) {
printaddr(addr);
return;
}
tprint_struct_begin();
PRINT_FIELD_XVAL(*h, version, cap_version,
"_LINUX_CAPABILITY_VERSION_???");
tprint_struct_next();
PRINT_FIELD_TGID(*h, pid, tcp);
tprint_struct_end();
}
static void
print_cap_bits(const uint32_t lo, const uint32_t hi)
{
if (lo || !hi)
printflags(cap_mask0, lo, "CAP_???");
if (hi) {
if (lo)
tprints("|");
printflags(cap_mask1, hi, "CAP_???");
}
}
static void
print_cap_data(struct tcb *const tcp, const kernel_ulong_t addr,
const struct user_cap_header_struct *const h)
{
struct user_cap_data_struct data[2];
unsigned int len;
if (!addr || !h) {
printaddr(addr);
return;
}
if (_LINUX_CAPABILITY_VERSION_2 == h->version ||
_LINUX_CAPABILITY_VERSION_3 == h->version)
len = 2;
else
len = 1;
if (umoven_or_printaddr(tcp, addr, len * sizeof(data[0]), data))
return;
tprint_struct_begin();
tprints_field_name("effective");
print_cap_bits(data[0].effective, len > 1 ? data[1].effective : 0);
tprint_struct_next();
tprints_field_name("permitted");
print_cap_bits(data[0].permitted, len > 1 ? data[1].permitted : 0);
tprint_struct_next();
tprints_field_name("inheritable");
print_cap_bits(data[0].inheritable, len > 1 ? data[1].inheritable : 0);
tprint_struct_end();
}
SYS_FUNC(capget)
{
const struct user_cap_header_struct *h;
if (entering(tcp)) {
h = get_cap_header(tcp, tcp->u_arg[0]);
print_cap_header(tcp, tcp->u_arg[0], h);
tprints(", ");
} else {
h = syserror(tcp) ? NULL : get_cap_header(tcp, tcp->u_arg[0]);
print_cap_data(tcp, tcp->u_arg[1], h);
}
return 0;
}
SYS_FUNC(capset)
{
const struct user_cap_header_struct *const h =
get_cap_header(tcp, tcp->u_arg[0]);
print_cap_header(tcp, tcp->u_arg[0], h);
tprints(", ");
print_cap_data(tcp, tcp->u_arg[1], h);
return RVAL_DECODED;
}
|
