2006-04-11 21:52:54 +00:00
|
|
|
/*
|
2007-04-11 08:12:51 +00:00
|
|
|
* Copyright (c) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
|
|
|
|
|
* NOVELL (All rights reserved)
|
2006-04-11 21:52:54 +00:00
|
|
|
*
|
2013-10-14 14:34:12 -07:00
|
|
|
* Copyright (c) 2013
|
|
|
|
|
* Canonical Ltd. (All rights reserved)
|
|
|
|
|
*
|
2006-04-11 21:52:54 +00:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of version 2 of the GNU General Public
|
|
|
|
|
* License published by the Free Software Foundation.
|
|
|
|
|
*
|
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
|
* along with this program; if not, contact Novell, Inc.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* assistance routines */
|
|
|
|
|
|
2012-01-02 16:48:44 -08:00
|
|
|
#include <assert.h>
|
2010-07-31 16:00:52 -07:00
|
|
|
#include <ctype.h>
|
2006-04-11 21:52:54 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#include <stdarg.h>
|
|
|
|
|
#include <string.h>
|
2007-11-16 09:32:38 +00:00
|
|
|
#include <linux/capability.h>
|
2011-03-03 15:45:10 -08:00
|
|
|
#include <sys/types.h>
|
|
|
|
|
#include <sys/stat.h>
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
#include <unistd.h>
|
2014-01-06 14:46:10 -08:00
|
|
|
#include <sys/apparmor.h>
|
2015-03-25 17:09:27 -05:00
|
|
|
#include <sys/apparmor_private.h>
|
2006-04-11 21:52:54 +00:00
|
|
|
|
2014-04-15 14:59:41 -07:00
|
|
|
#include "lib.h"
|
2006-04-11 21:52:54 +00:00
|
|
|
#include "parser.h"
|
2013-09-27 16:16:37 -07:00
|
|
|
#include "profile.h"
|
2006-04-11 21:52:54 +00:00
|
|
|
#include "parser_yacc.h"
|
Add mount rules
Add the ability to control mounting and unmounting
The basic form of the rules are.
[audit] [deny] mount [conds]* [device] [ -> [conds] path],
[audit] [deny] remount [conds]* [path],
[audit] [deny] umount [conds]* [path],
[audit] [deny] pivotroot [oldroot=<value>] <path> -> <profile>
remount is just a short cut for mount options=remount
where [conds] can be
fstype=<expr>
options=<expr>
conds follow the extended conditional syntax of allowing either:
* a single value after the equals, which has the same character range as
regular IDS (ie most anything but it can't be terminated with a , (comma)
and if spaces or other characters are needed it can be quoted
eg.
options=foo
options = foo
options="foo bar"
* a list of values after the equals, the list of values is enclosed within
parenthesis () and its has a slightly reduced character set but again
elements can be quoted.
the separation between elements is whitespace and commas.
eg.
options=(foo bar)
options=(foo, bar)
options=(foo , bar)
options=(foo,bar)
The rules are flexible and follow a similar pattern as network, capability,
etc.
mount, # allow all mounts, but not umount or pivotroot
mount fstype=procfs, # allow mounting procfs anywhere
mount options=(bind, ro) /foo -> /bar, # readonly bind mount
mount /dev/sda -> /mnt,
mount /dev/sd** -> /mnt/**,
mount fstype=overlayfs options=(rw,upperdir=/tmp/upper/,lowerdir=/) overlay -> /mnt/
umount,
umount /m*,
Currently variables and regexs are are supported on the device and mount
point. ie.
mount <devince> -> <mount point>,
Regexes are supported in fstype and options. The options have a further
caveat that regexs only work if the option is fs specific option.
eg. options=(upperdir=/tmp/*,lowerdir=/)
regex's will not currently work against the standard options like ro, rw
nosuid
Conditionals (fstype) can only be applied to the device (source) at this
time and will be disregarded in situations where the mount is manipulating
an existing mount (bind, remount).
Options can be specified multiple times
mount option=rw option=(nosuid,upperdir=/foo),
and will be combined together into a single set of values
The ordering of the standard mount options (rw,ro, ...) does not matter
but the ordering of fs specific options does.
Specifying that the value of a particular option does not matter can be
acheived by providing both the positive and negative forms of and option
option=(rw,ro) options=(suid,nosuid)
For the fs specific options specifying that a particular value does not
matter is achieve using a regex with alternations.
Improvements to the syntax and order restrictions are planned for the
future.
Signed-off-by: John Johansen <john.johansen@canonical.com>
2012-02-24 04:19:38 -08:00
|
|
|
#include "mount.h"
|
2013-07-31 09:05:51 -07:00
|
|
|
#include "dbus.h"
|
2006-04-11 21:52:54 +00:00
|
|
|
|
|
|
|
|
/* #define DEBUG */
|
|
|
|
|
#ifdef DEBUG
|
2010-07-26 09:22:45 -07:00
|
|
|
#undef PDEBUG
|
2015-03-02 09:50:11 -06:00
|
|
|
#define PDEBUG(fmt, args...) fprintf(stderr, "Lexer: " fmt, ## args)
|
2006-04-11 21:52:54 +00:00
|
|
|
#else
|
2010-07-26 09:22:45 -07:00
|
|
|
#undef PDEBUG
|
2006-04-11 21:52:54 +00:00
|
|
|
#define PDEBUG(fmt, args...) /* Do nothing */
|
|
|
|
|
#endif
|
|
|
|
|
#define NPDEBUG(fmt, args...) /* Do nothing */
|
|
|
|
|
|
2013-10-26 00:15:13 -07:00
|
|
|
int is_blacklisted(const char *name, const char *path)
|
|
|
|
|
{
|
2015-06-16 15:49:51 -05:00
|
|
|
int retval = _aa_is_blacklisted(name);
|
2013-10-26 00:15:13 -07:00
|
|
|
|
2015-03-25 17:09:27 -05:00
|
|
|
if (retval == -1)
|
|
|
|
|
PERROR("Ignoring: '%s'\n", path ? path : name);
|
2013-10-26 00:15:13 -07:00
|
|
|
|
2015-03-25 17:09:27 -05:00
|
|
|
return !retval ? 0 : 1;
|
2013-10-26 00:15:13 -07:00
|
|
|
}
|
|
|
|
|
|
2006-04-11 21:52:54 +00:00
|
|
|
struct keyword_table {
|
2013-09-27 16:13:22 -07:00
|
|
|
const char *keyword;
|
2006-04-11 21:52:54 +00:00
|
|
|
int token;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct keyword_table keyword_table[] = {
|
|
|
|
|
/* network */
|
2007-07-27 20:29:47 +00:00
|
|
|
{"network", TOK_NETWORK},
|
parser: first step implementing fine grained mediation for unix domain sockets
This patch implements parsing of fine grained mediation for unix domain
sockets, that have abstract and anonymous paths. Sockets with file
system paths are handled by regular file access rules.
The unix network rules follow the general fine grained network
rule pattern of
[<qualifiers>] af_name [<access expr>] [<rule conds>] [<local expr>] [<peer expr>]
specifically for af_unix this is
[<qualifiers>] 'unix' [<access expr>] [<rule conds>] [<local expr>] [<peer expr>]
<qualifiers> = [ 'audit' ] [ 'allow' | 'deny' ]
<access expr> = ( <access> | <access list> )
<access> = ( 'server' | 'create' | 'bind' | 'listen' | 'accept' |
'connect' | 'shutdown' | 'getattr' | 'setattr' |
'getopt' | 'setopt' |
'send' | 'receive' | 'r' | 'w' | 'rw' )
(some access modes are incompatible with some rules or require additional
parameters)
<access list> = '(' <access> ( [','] <WS> <access> )* ')'
<WS> = white space
<rule conds> = ( <type cond> | <protocol cond> )*
each cond can appear at most once
<type cond> = 'type' '=' ( <AARE> | '(' ( '"' <AARE> '"' | <AARE> )+ ')' )
<protocol cond> = 'protocol' '=' ( <AARE> | '(' ( '"' <AARE> '"' | <AARE> )+ ')' )
<local expr> = ( <path cond> | <attr cond> | <opt cond> )*
each cond can appear at most once
<peer expr> = 'peer' '=' ( <path cond> | <label cond> )+
each cond can appear at most once
<path cond> = 'path' '=' ( <AARE> | '(' '"' <AARE> '"' | <AARE> ')' )
<label cond> = 'label' '=' ( <AARE> | '(' '"' <AARE> '"' | <AARE> ')')
<attr cond> = 'attr' '=' ( <AARE> | '(' '"' <AARE> '"' | <AARE> ')' )
<opt cond> = 'opt' '=' ( <AARE> | '(' '"' <AARE> '"' | <AARE> ')' )
<AARE> = ?*[]{}^ ( see man page )
unix domain socket rules are accumulated so that the granted unix
socket permissions are the union of all the listed unix rule permissions.
unix domain socket rules are broad and general and become more restrictive
as further information is specified. Policy may be specified down to
the path and label level. The content of the communication is not
examined.
Some permissions are not compatible with all unix rules.
unix socket rule permissions are implied when a rule does not explicitly
state an access list. By default if a rule does not have an access list
all permissions that are compatible with the specified set of local
and peer conditionals are implied.
The 'server', 'r', 'w' and 'rw' permissions are aliases for other permissions.
server = (create, bind, listen, accept)
r = (receive, getattr, getopt)
w = (create, connect, send, setattr, setopt)
In addition it supports the v7 kernel abi semantics around generic
network rules. The v7 abi removes the masking unix and netlink
address families from the generic masking and uses fine grained
mediation for an address type if supplied.
This means that the rules
network unix,
network netlink,
are now enforced instead of ignored. The parser previously could accept
these but the kernel would ignore anything written to them. If a network
rule is supplied it takes precedence over the finer grained mediation
rule. If permission is not granted via a broad network access rule
fine grained mediation is applied.
Signed-off-by: John Johansen <john.johansen@canonical.com>
Acked-by: Seth Arnold <seth.arnold@canonical.com>
2014-09-03 13:22:26 -07:00
|
|
|
{"unix", TOK_UNIX},
|
2006-04-11 21:52:54 +00:00
|
|
|
/* misc keywords */
|
2007-11-16 09:32:38 +00:00
|
|
|
{"capability", TOK_CAPABILITY},
|
2006-04-11 21:52:54 +00:00
|
|
|
{"if", TOK_IF},
|
|
|
|
|
{"else", TOK_ELSE},
|
|
|
|
|
{"not", TOK_NOT},
|
|
|
|
|
{"defined", TOK_DEFINED},
|
2007-06-26 21:10:28 +00:00
|
|
|
{"change_profile", TOK_CHANGE_PROFILE},
|
2007-07-27 20:55:25 +00:00
|
|
|
{"unsafe", TOK_UNSAFE},
|
2010-12-20 11:58:05 -08:00
|
|
|
{"safe", TOK_SAFE},
|
2007-11-16 09:37:31 +00:00
|
|
|
{"link", TOK_LINK},
|
2007-11-29 18:06:53 +00:00
|
|
|
{"owner", TOK_OWNER},
|
Add Audit control to AppArmor through, the use of audit and deny
key words. Deny is also used to subtract permissions from the
profiles permission set.
the audit key word can be prepended to any file, network, or capability
rule, to force a selective audit when that rule is matched. Audit
permissions accumulate just like standard permissions.
eg.
audit /bin/foo rw,
will force an audit message when the file /bin/foo is opened for
read or write.
audit /etc/shadow w,
/etc/shadow r,
will force an audit message when /etc/shadow is opened for writing.
The audit message is per permission bit so only opening the file
for read access will not, force an audit message.
audit can also be used in block form instead of prepending audit
to every rule.
audit {
/bin/foo rw,
/etc/shadow w,
}
/etc/shadow r, # don't audit r access to /etc/shadow
the deny key word can be prepended to file, network and capability
rules, to result in a denial of permissions when matching that rule.
The deny rule specifically does 3 things
- it gives AppArmor the ability to remember what has been denied
so that the tools don't prompt for what has been denied in
previous profiling sessions.
- it subtracts globally from the allowed permissions. Deny permissions
accumulate in the the deny set just as allow permissions accumulate
then, the deny set is subtracted from the allow set.
- it quiets known rejects. The default audit behavior of deny rules
is to quiet known rejects so that audit logs are not flooded
with already known rejects. To have known rejects logged prepend
the audit keyword to the deny rule. Deny rules do not have a
block form.
eg.
deny /foo/bar rw,
audit deny /etc/shadow w,
audit {
deny owner /blah w,
deny other /foo w,
deny /etc/shadow w,
}
2008-03-13 17:39:03 +00:00
|
|
|
{"user", TOK_OWNER},
|
|
|
|
|
{"other", TOK_OTHER},
|
2008-03-13 16:49:10 +00:00
|
|
|
{"subset", TOK_SUBSET},
|
Add Audit control to AppArmor through, the use of audit and deny
key words. Deny is also used to subtract permissions from the
profiles permission set.
the audit key word can be prepended to any file, network, or capability
rule, to force a selective audit when that rule is matched. Audit
permissions accumulate just like standard permissions.
eg.
audit /bin/foo rw,
will force an audit message when the file /bin/foo is opened for
read or write.
audit /etc/shadow w,
/etc/shadow r,
will force an audit message when /etc/shadow is opened for writing.
The audit message is per permission bit so only opening the file
for read access will not, force an audit message.
audit can also be used in block form instead of prepending audit
to every rule.
audit {
/bin/foo rw,
/etc/shadow w,
}
/etc/shadow r, # don't audit r access to /etc/shadow
the deny key word can be prepended to file, network and capability
rules, to result in a denial of permissions when matching that rule.
The deny rule specifically does 3 things
- it gives AppArmor the ability to remember what has been denied
so that the tools don't prompt for what has been denied in
previous profiling sessions.
- it subtracts globally from the allowed permissions. Deny permissions
accumulate in the the deny set just as allow permissions accumulate
then, the deny set is subtracted from the allow set.
- it quiets known rejects. The default audit behavior of deny rules
is to quiet known rejects so that audit logs are not flooded
with already known rejects. To have known rejects logged prepend
the audit keyword to the deny rule. Deny rules do not have a
block form.
eg.
deny /foo/bar rw,
audit deny /etc/shadow w,
audit {
deny owner /blah w,
deny other /foo w,
deny /etc/shadow w,
}
2008-03-13 17:39:03 +00:00
|
|
|
{"audit", TOK_AUDIT},
|
|
|
|
|
{"deny", TOK_DENY},
|
2013-09-20 06:48:56 -07:00
|
|
|
{"allow", TOK_ALLOW},
|
2008-04-06 18:55:27 +00:00
|
|
|
{"set", TOK_SET},
|
2008-04-06 18:55:46 +00:00
|
|
|
{"rlimit", TOK_RLIMIT},
|
2008-04-09 09:03:17 +00:00
|
|
|
{"alias", TOK_ALIAS},
|
2009-06-10 20:26:31 +00:00
|
|
|
{"rewrite", TOK_ALIAS},
|
2008-04-09 09:04:08 +00:00
|
|
|
{"ptrace", TOK_PTRACE},
|
2012-02-16 08:06:04 -08:00
|
|
|
{"file", TOK_FILE},
|
Add mount rules
Add the ability to control mounting and unmounting
The basic form of the rules are.
[audit] [deny] mount [conds]* [device] [ -> [conds] path],
[audit] [deny] remount [conds]* [path],
[audit] [deny] umount [conds]* [path],
[audit] [deny] pivotroot [oldroot=<value>] <path> -> <profile>
remount is just a short cut for mount options=remount
where [conds] can be
fstype=<expr>
options=<expr>
conds follow the extended conditional syntax of allowing either:
* a single value after the equals, which has the same character range as
regular IDS (ie most anything but it can't be terminated with a , (comma)
and if spaces or other characters are needed it can be quoted
eg.
options=foo
options = foo
options="foo bar"
* a list of values after the equals, the list of values is enclosed within
parenthesis () and its has a slightly reduced character set but again
elements can be quoted.
the separation between elements is whitespace and commas.
eg.
options=(foo bar)
options=(foo, bar)
options=(foo , bar)
options=(foo,bar)
The rules are flexible and follow a similar pattern as network, capability,
etc.
mount, # allow all mounts, but not umount or pivotroot
mount fstype=procfs, # allow mounting procfs anywhere
mount options=(bind, ro) /foo -> /bar, # readonly bind mount
mount /dev/sda -> /mnt,
mount /dev/sd** -> /mnt/**,
mount fstype=overlayfs options=(rw,upperdir=/tmp/upper/,lowerdir=/) overlay -> /mnt/
umount,
umount /m*,
Currently variables and regexs are are supported on the device and mount
point. ie.
mount <devince> -> <mount point>,
Regexes are supported in fstype and options. The options have a further
caveat that regexs only work if the option is fs specific option.
eg. options=(upperdir=/tmp/*,lowerdir=/)
regex's will not currently work against the standard options like ro, rw
nosuid
Conditionals (fstype) can only be applied to the device (source) at this
time and will be disregarded in situations where the mount is manipulating
an existing mount (bind, remount).
Options can be specified multiple times
mount option=rw option=(nosuid,upperdir=/foo),
and will be combined together into a single set of values
The ordering of the standard mount options (rw,ro, ...) does not matter
but the ordering of fs specific options does.
Specifying that the value of a particular option does not matter can be
acheived by providing both the positive and negative forms of and option
option=(rw,ro) options=(suid,nosuid)
For the fs specific options specifying that a particular value does not
matter is achieve using a regex with alternations.
Improvements to the syntax and order restrictions are planned for the
future.
Signed-off-by: John Johansen <john.johansen@canonical.com>
2012-02-24 04:19:38 -08:00
|
|
|
{"mount", TOK_MOUNT},
|
|
|
|
|
{"remount", TOK_REMOUNT},
|
|
|
|
|
{"umount", TOK_UMOUNT},
|
|
|
|
|
{"unmount", TOK_UMOUNT},
|
2012-03-15 12:14:15 -07:00
|
|
|
{"pivot_root", TOK_PIVOTROOT},
|
2012-03-26 06:17:40 -07:00
|
|
|
{"in", TOK_IN},
|
2013-07-31 09:05:51 -07:00
|
|
|
{"dbus", TOK_DBUS},
|
2014-04-23 11:35:29 -07:00
|
|
|
{"signal", TOK_SIGNAL},
|
2013-07-31 09:05:51 -07:00
|
|
|
{"send", TOK_SEND},
|
|
|
|
|
{"receive", TOK_RECEIVE},
|
|
|
|
|
{"bind", TOK_BIND},
|
|
|
|
|
{"read", TOK_READ},
|
|
|
|
|
{"write", TOK_WRITE},
|
parser: Add dbus eavesdrop permission support to apparmor_parser
Allows for the policy writer to grant permission to eavesdrop on the
specified bus. Some example rules for granting the eavesdrop permission
are:
# Grant send, receive, bind, and eavesdrop
dbus,
# Grant send, receive, bind, and eavesdrop on the session bus
dbus bus=session,
# Grant send and eavesdrop on the system bus
dbus (send eavesdrop) bus=system,
# Grant eavesdrop on any bus
dbus eavesdrop,
Eavesdropping rules can contain the bus conditional. Any other
conditionals are not compatible with eavesdropping rules and the parser
will return an error.
Signed-off-by: Tyler Hicks <tyhicks@canonical.com>
Acked-by: Seth Arnold <seth.arnold@canonical.com>
2013-12-06 11:17:43 -08:00
|
|
|
{"eavesdrop", TOK_EAVESDROP},
|
2013-07-31 09:05:51 -07:00
|
|
|
{"peer", TOK_PEER},
|
2014-04-23 11:38:04 -07:00
|
|
|
{"trace", TOK_TRACE},
|
|
|
|
|
{"tracedby", TOK_TRACEDBY},
|
|
|
|
|
{"readby", TOK_READBY},
|
2013-07-31 09:05:51 -07:00
|
|
|
|
2008-04-06 18:55:46 +00:00
|
|
|
/* terminate */
|
|
|
|
|
{NULL, 0}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct keyword_table rlimit_table[] = {
|
|
|
|
|
{"cpu", RLIMIT_CPU},
|
|
|
|
|
{"fsize", RLIMIT_FSIZE},
|
|
|
|
|
{"data", RLIMIT_DATA},
|
|
|
|
|
{"stack", RLIMIT_STACK},
|
|
|
|
|
{"core", RLIMIT_CORE},
|
|
|
|
|
{"rss", RLIMIT_RSS},
|
|
|
|
|
{"nofile", RLIMIT_NOFILE},
|
|
|
|
|
{"ofile", RLIMIT_OFILE},
|
|
|
|
|
{"as", RLIMIT_AS},
|
|
|
|
|
{"nproc", RLIMIT_NPROC},
|
|
|
|
|
{"memlock", RLIMIT_MEMLOCK},
|
|
|
|
|
{"locks", RLIMIT_LOCKS},
|
|
|
|
|
{"sigpending", RLIMIT_SIGPENDING},
|
|
|
|
|
{"msgqueue", RLIMIT_MSGQUEUE},
|
2008-06-09 21:17:41 +00:00
|
|
|
#ifdef RLIMIT_NICE
|
2008-04-06 18:55:46 +00:00
|
|
|
{"nice", RLIMIT_NICE},
|
2008-06-09 21:17:41 +00:00
|
|
|
#endif
|
|
|
|
|
#ifdef RLIMIT_RTPRIO
|
2008-04-06 18:55:46 +00:00
|
|
|
{"rtprio", RLIMIT_RTPRIO},
|
2014-01-24 11:06:31 -08:00
|
|
|
#endif
|
|
|
|
|
#ifdef RLIMIT_RTTIME
|
|
|
|
|
{"rttime", RLIMIT_RTTIME},
|
2008-06-09 21:17:41 +00:00
|
|
|
#endif
|
2006-04-11 21:52:54 +00:00
|
|
|
/* terminate */
|
|
|
|
|
{NULL, 0}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* for alpha matches, check for keywords */
|
2014-10-02 12:58:54 -07:00
|
|
|
static int get_table_token(const char *name unused, struct keyword_table *table,
|
2007-11-16 09:32:38 +00:00
|
|
|
const char *keyword)
|
2006-04-11 21:52:54 +00:00
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
2007-11-16 09:32:38 +00:00
|
|
|
for (i = 0; table[i].keyword; i++) {
|
|
|
|
|
PDEBUG("Checking %s %s\n", name, table[i].keyword);
|
|
|
|
|
if (strcmp(keyword, table[i].keyword) == 0) {
|
|
|
|
|
PDEBUG("Found %s %s\n", name, table[i].keyword);
|
|
|
|
|
return table[i].token;
|
2006-04-11 21:52:54 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-11-16 09:32:38 +00:00
|
|
|
PDEBUG("Unable to find %s %s\n", name, keyword);
|
2006-04-11 21:52:54 +00:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
2007-11-16 09:32:38 +00:00
|
|
|
static struct keyword_table capability_table[] = {
|
|
|
|
|
/* capabilities */
|
|
|
|
|
#include "cap_names.h"
|
2011-08-18 23:54:24 +02:00
|
|
|
#ifndef CAP_SYSLOG
|
|
|
|
|
{"syslog", 34},
|
|
|
|
|
#endif
|
2007-11-16 09:32:38 +00:00
|
|
|
/* terminate */
|
|
|
|
|
{NULL, 0}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* for alpha matches, check for keywords */
|
|
|
|
|
int get_keyword_token(const char *keyword)
|
|
|
|
|
{
|
|
|
|
|
return get_table_token("keyword", keyword_table, keyword);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int name_to_capability(const char *keyword)
|
|
|
|
|
{
|
|
|
|
|
return get_table_token("capability", capability_table, keyword);
|
|
|
|
|
}
|
|
|
|
|
|
2008-04-06 18:55:46 +00:00
|
|
|
int get_rlimit(const char *name)
|
|
|
|
|
{
|
|
|
|
|
return get_table_token("rlimit", rlimit_table, name);
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-01 10:59:04 -07:00
|
|
|
char *processunquoted(const char *string, int len)
|
2006-04-11 21:52:54 +00:00
|
|
|
{
|
2014-04-15 14:59:41 -07:00
|
|
|
char *buffer, *s;
|
2006-04-11 21:52:54 +00:00
|
|
|
|
2014-04-15 14:59:41 -07:00
|
|
|
s = buffer = (char *) malloc(len + 1);
|
|
|
|
|
if (!buffer)
|
2006-04-11 21:52:54 +00:00
|
|
|
return NULL;
|
|
|
|
|
|
2014-04-15 14:59:41 -07:00
|
|
|
while (len > 0) {
|
|
|
|
|
const char *pos = string + 1;
|
|
|
|
|
long c;
|
|
|
|
|
if (*string == '\\' && len > 1 &&
|
|
|
|
|
(c = strn_escseq(&pos, "", len)) != -1) {
|
2014-06-19 13:49:53 -07:00
|
|
|
/* catch \\ or \134 and other aare special chars and
|
|
|
|
|
* pass it through to be handled by the backend
|
|
|
|
|
* pcre conversion
|
2014-06-19 13:47:39 -07:00
|
|
|
*/
|
2015-02-12 10:19:16 -08:00
|
|
|
if (c == 0) {
|
|
|
|
|
strncpy(s, string, pos - string);
|
|
|
|
|
s += pos - string;
|
|
|
|
|
} else if (strchr("*?[]{}^,\\", c) != NULL) {
|
2014-06-19 13:47:39 -07:00
|
|
|
*s++ = '\\';
|
2014-06-19 13:49:53 -07:00
|
|
|
*s++ = c;
|
2014-06-19 13:47:39 -07:00
|
|
|
} else
|
|
|
|
|
*s++ = c;
|
2014-04-15 14:59:41 -07:00
|
|
|
len -= pos - string;
|
|
|
|
|
string = pos;
|
2006-04-11 21:52:54 +00:00
|
|
|
} else {
|
2014-04-15 14:59:41 -07:00
|
|
|
/* either unescaped char OR
|
|
|
|
|
* unsupported escape sequence resulting in char being
|
|
|
|
|
* copied.
|
|
|
|
|
*/
|
|
|
|
|
*s++ = *string++;
|
|
|
|
|
len--;
|
2006-04-11 21:52:54 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
*s = 0;
|
|
|
|
|
|
2014-04-15 14:59:41 -07:00
|
|
|
return buffer;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* rewrite a quoted string substituting escaped characters for the
|
|
|
|
|
* real thing. Strip the quotes around the string */
|
|
|
|
|
char *processquoted(const char *string, int len)
|
|
|
|
|
{
|
|
|
|
|
/* skip leading " and eat trailing " */
|
|
|
|
|
if (*string == '"') {
|
|
|
|
|
len -= 2;
|
|
|
|
|
if (len < 0) /* start and end point to same quote */
|
|
|
|
|
len = 0;
|
|
|
|
|
return processunquoted(string + 1, len);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* no quotes? treat as unquoted */
|
|
|
|
|
return processunquoted(string, len);
|
2012-01-02 16:48:44 -08:00
|
|
|
}
|
|
|
|
|
|
2013-10-01 10:59:04 -07:00
|
|
|
char *processid(const char *string, int len)
|
2012-01-02 16:48:44 -08:00
|
|
|
{
|
|
|
|
|
/* lexer should never call this fn if len <= 0 */
|
|
|
|
|
assert(len > 0);
|
|
|
|
|
|
|
|
|
|
if (*string == '"')
|
|
|
|
|
return processquoted(string, len);
|
|
|
|
|
return processunquoted(string, len);
|
2006-04-11 21:52:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* strip off surrounding delimiters around variables */
|
|
|
|
|
char *process_var(const char *var)
|
|
|
|
|
{
|
|
|
|
|
const char *orig = var;
|
|
|
|
|
int len = strlen(var);
|
|
|
|
|
|
|
|
|
|
if (*orig == '@' || *orig == '$') {
|
|
|
|
|
orig++;
|
|
|
|
|
len--;
|
|
|
|
|
} else {
|
|
|
|
|
PERROR("ASSERT: Found var '%s' without variable prefix\n",
|
|
|
|
|
var);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (*orig == '{') {
|
|
|
|
|
orig++;
|
|
|
|
|
len--;
|
|
|
|
|
if (orig[len - 1] != '}') {
|
|
|
|
|
PERROR("ASSERT: No matching '}' in variable '%s'\n",
|
|
|
|
|
var);
|
|
|
|
|
return NULL;
|
|
|
|
|
} else
|
|
|
|
|
len--;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return strndup(orig, len);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* returns -1 if value != true or false, otherwise 0 == false, 1 == true */
|
|
|
|
|
int str_to_boolean(const char *value)
|
|
|
|
|
{
|
|
|
|
|
int retval = -1;
|
|
|
|
|
|
|
|
|
|
if (strcasecmp("TRUE", value) == 0)
|
|
|
|
|
retval = 1;
|
|
|
|
|
if (strcasecmp("FALSE", value) == 0)
|
|
|
|
|
retval = 0;
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
static int warned_uppercase = 0;
|
|
|
|
|
|
2014-04-07 03:16:50 -07:00
|
|
|
void warn_uppercase(void)
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
{
|
|
|
|
|
if (!warned_uppercase) {
|
2006-08-04 17:20:16 +00:00
|
|
|
pwarn(_("Uppercase qualifiers \"RWLIMX\" are deprecated, please convert to lowercase\n"
|
|
|
|
|
"See the apparmor.d(5) manpage for details.\n"));
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
warned_uppercase = 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
2007-11-16 09:35:31 +00:00
|
|
|
|
2014-10-02 12:58:54 -07:00
|
|
|
static int parse_sub_mode(const char *str_mode, const char *mode_desc unused)
|
2006-04-11 21:52:54 +00:00
|
|
|
{
|
|
|
|
|
|
2008-04-16 04:44:21 +00:00
|
|
|
#define IS_DIFF_QUAL(mode, q) (((mode) & AA_MAY_EXEC) && (((mode) & AA_EXEC_TYPE) != ((q) & AA_EXEC_TYPE)))
|
2006-04-11 21:52:54 +00:00
|
|
|
|
|
|
|
|
int mode = 0;
|
|
|
|
|
const char *p;
|
|
|
|
|
|
|
|
|
|
PDEBUG("Parsing mode: %s\n", str_mode);
|
|
|
|
|
|
2007-06-26 21:10:28 +00:00
|
|
|
if (!str_mode)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2006-04-11 21:52:54 +00:00
|
|
|
p = str_mode;
|
|
|
|
|
while (*p) {
|
2013-09-27 16:13:22 -07:00
|
|
|
char thisc = *p;
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
char next = *(p + 1);
|
|
|
|
|
char lower;
|
2007-11-16 09:27:34 +00:00
|
|
|
int tmode = 0;
|
2006-04-11 21:52:54 +00:00
|
|
|
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
reeval:
|
2013-09-27 16:13:22 -07:00
|
|
|
switch (thisc) {
|
2006-04-11 21:52:54 +00:00
|
|
|
case COD_READ_CHAR:
|
2009-06-10 15:37:27 +00:00
|
|
|
if (read_implies_exec) {
|
2009-06-10 17:51:09 +00:00
|
|
|
PDEBUG("Parsing mode: found %s READ imply X\n", mode_desc);
|
2015-06-06 01:25:49 -07:00
|
|
|
mode |= AA_MAY_READ | AA_OLD_EXEC_MMAP;
|
2009-06-10 15:37:27 +00:00
|
|
|
} else {
|
|
|
|
|
PDEBUG("Parsing mode: found %s READ\n", mode_desc);
|
|
|
|
|
mode |= AA_MAY_READ;
|
|
|
|
|
}
|
2006-04-11 21:52:54 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case COD_WRITE_CHAR:
|
2007-11-16 09:35:31 +00:00
|
|
|
PDEBUG("Parsing mode: found %s WRITE\n", mode_desc);
|
2007-07-27 20:31:38 +00:00
|
|
|
if ((mode & AA_MAY_APPEND) && !(mode & AA_MAY_WRITE))
|
|
|
|
|
yyerror(_("Conflict 'a' and 'w' perms are mutually exclusive."));
|
|
|
|
|
mode |= AA_MAY_WRITE | AA_MAY_APPEND;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case COD_APPEND_CHAR:
|
2007-11-16 09:35:31 +00:00
|
|
|
PDEBUG("Parsing mode: found %s APPEND\n", mode_desc);
|
2007-07-27 20:31:38 +00:00
|
|
|
if (mode & AA_MAY_WRITE)
|
|
|
|
|
yyerror(_("Conflict 'a' and 'w' perms are mutually exclusive."));
|
|
|
|
|
mode |= AA_MAY_APPEND;
|
2006-04-11 21:52:54 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case COD_LINK_CHAR:
|
2007-11-16 09:35:31 +00:00
|
|
|
PDEBUG("Parsing mode: found %s LINK\n", mode_desc);
|
2015-06-06 01:25:49 -07:00
|
|
|
mode |= AA_OLD_MAY_LINK;
|
2006-04-11 21:52:54 +00:00
|
|
|
break;
|
|
|
|
|
|
2007-07-27 20:38:43 +00:00
|
|
|
case COD_LOCK_CHAR:
|
2007-11-16 09:35:31 +00:00
|
|
|
PDEBUG("Parsing mode: found %s LOCK\n", mode_desc);
|
2015-06-06 01:25:49 -07:00
|
|
|
mode |= AA_OLD_MAY_LOCK;
|
2007-07-27 20:38:43 +00:00
|
|
|
break;
|
|
|
|
|
|
2006-04-11 21:52:54 +00:00
|
|
|
case COD_INHERIT_CHAR:
|
|
|
|
|
PDEBUG("Parsing mode: found INHERIT\n");
|
2008-04-16 04:44:21 +00:00
|
|
|
if (mode & AA_EXEC_MODIFIERS) {
|
2006-04-11 21:52:54 +00:00
|
|
|
yyerror(_("Exec qualifier 'i' invalid, conflicting qualifier already specified"));
|
|
|
|
|
} else {
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
if (next != tolower(next))
|
|
|
|
|
warn_uppercase();
|
2007-11-16 09:27:34 +00:00
|
|
|
mode |= (AA_EXEC_INHERIT | AA_MAY_EXEC);
|
2006-04-11 21:52:54 +00:00
|
|
|
p++; /* skip 'x' */
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
2007-07-27 20:45:45 +00:00
|
|
|
case COD_UNSAFE_UNCONFINED_CHAR:
|
2007-11-16 09:27:34 +00:00
|
|
|
tmode = AA_EXEC_UNSAFE;
|
2007-07-27 20:45:45 +00:00
|
|
|
pwarn(_("Unconfined exec qualifier (%c%c) allows some dangerous environment variables "
|
2006-08-04 17:20:16 +00:00
|
|
|
"to be passed to the unconfined process; 'man 5 apparmor.d' for details.\n"),
|
2007-07-27 20:45:45 +00:00
|
|
|
COD_UNSAFE_UNCONFINED_CHAR, COD_EXEC_CHAR);
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
/* fall through */
|
2007-07-27 20:45:45 +00:00
|
|
|
case COD_UNCONFINED_CHAR:
|
2008-04-16 04:44:21 +00:00
|
|
|
tmode |= AA_EXEC_UNCONFINED | AA_MAY_EXEC;
|
2007-07-27 20:45:45 +00:00
|
|
|
PDEBUG("Parsing mode: found UNCONFINED\n");
|
2008-04-16 04:44:21 +00:00
|
|
|
if (IS_DIFF_QUAL(mode, tmode)) {
|
2006-08-04 17:20:16 +00:00
|
|
|
yyerror(_("Exec qualifier '%c' invalid, conflicting qualifier already specified"),
|
2013-09-27 16:13:22 -07:00
|
|
|
thisc);
|
2006-04-11 21:52:54 +00:00
|
|
|
} else {
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
if (next != tolower(next))
|
|
|
|
|
warn_uppercase();
|
2008-04-16 04:44:21 +00:00
|
|
|
mode |= tmode;
|
2006-04-11 21:52:54 +00:00
|
|
|
p++; /* skip 'x' */
|
|
|
|
|
}
|
2007-11-16 09:27:34 +00:00
|
|
|
tmode = 0;
|
2006-04-11 21:52:54 +00:00
|
|
|
break;
|
|
|
|
|
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
case COD_UNSAFE_PROFILE_CHAR:
|
2008-04-16 04:44:21 +00:00
|
|
|
case COD_UNSAFE_LOCAL_CHAR:
|
2007-11-16 09:27:34 +00:00
|
|
|
tmode = AA_EXEC_UNSAFE;
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
/* fall through */
|
2006-04-11 21:52:54 +00:00
|
|
|
case COD_PROFILE_CHAR:
|
2008-04-16 04:44:21 +00:00
|
|
|
case COD_LOCAL_CHAR:
|
2013-09-27 16:13:22 -07:00
|
|
|
if (tolower(thisc) == COD_UNSAFE_PROFILE_CHAR)
|
2008-04-16 04:44:21 +00:00
|
|
|
tmode |= AA_EXEC_PROFILE | AA_MAY_EXEC;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
tmode |= AA_EXEC_LOCAL | AA_MAY_EXEC;
|
|
|
|
|
}
|
2006-04-11 21:52:54 +00:00
|
|
|
PDEBUG("Parsing mode: found PROFILE\n");
|
2007-11-16 09:27:34 +00:00
|
|
|
if (tolower(next) == COD_INHERIT_CHAR) {
|
2008-04-16 04:44:21 +00:00
|
|
|
tmode |= AA_EXEC_INHERIT;
|
|
|
|
|
if (IS_DIFF_QUAL(mode, tmode)) {
|
2013-09-27 16:13:22 -07:00
|
|
|
yyerror(_("Exec qualifier '%c%c' invalid, conflicting qualifier already specified"), thisc, next);
|
2007-11-16 09:27:34 +00:00
|
|
|
} else {
|
2008-04-16 04:44:21 +00:00
|
|
|
mode |= tmode;
|
2007-11-16 09:27:34 +00:00
|
|
|
p += 2; /* skip x */
|
|
|
|
|
}
|
2009-08-20 15:41:10 +00:00
|
|
|
} else if (tolower(next) == COD_UNSAFE_UNCONFINED_CHAR) {
|
|
|
|
|
tmode |= AA_EXEC_PUX;
|
|
|
|
|
if (IS_DIFF_QUAL(mode, tmode)) {
|
2013-09-27 16:13:22 -07:00
|
|
|
yyerror(_("Exec qualifier '%c%c' invalid, conflicting qualifier already specified"), thisc, next);
|
2009-08-20 15:41:10 +00:00
|
|
|
} else {
|
|
|
|
|
mode |= tmode;
|
|
|
|
|
p += 2; /* skip x */
|
|
|
|
|
}
|
2008-04-16 04:44:21 +00:00
|
|
|
} else if (IS_DIFF_QUAL(mode, tmode)) {
|
2013-09-27 16:13:22 -07:00
|
|
|
yyerror(_("Exec qualifier '%c' invalid, conflicting qualifier already specified"), thisc);
|
2008-04-16 04:44:21 +00:00
|
|
|
|
2006-04-11 21:52:54 +00:00
|
|
|
} else {
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
if (next != tolower(next))
|
|
|
|
|
warn_uppercase();
|
2008-04-16 04:44:21 +00:00
|
|
|
mode |= tmode;
|
2006-04-11 21:52:54 +00:00
|
|
|
p++; /* skip 'x' */
|
|
|
|
|
}
|
2007-11-16 09:27:34 +00:00
|
|
|
tmode = 0;
|
2006-04-11 21:52:54 +00:00
|
|
|
break;
|
|
|
|
|
|
2006-08-04 17:14:06 +00:00
|
|
|
case COD_MMAP_CHAR:
|
2007-11-16 09:35:31 +00:00
|
|
|
PDEBUG("Parsing mode: found %s MMAP\n", mode_desc);
|
2015-06-06 01:25:49 -07:00
|
|
|
mode |= AA_OLD_EXEC_MMAP;
|
2006-08-04 17:14:06 +00:00
|
|
|
break;
|
|
|
|
|
|
2006-04-11 21:52:54 +00:00
|
|
|
case COD_EXEC_CHAR:
|
2013-09-27 16:13:22 -07:00
|
|
|
/* thisc is valid for deny rules, and named transitions
|
Add Audit control to AppArmor through, the use of audit and deny
key words. Deny is also used to subtract permissions from the
profiles permission set.
the audit key word can be prepended to any file, network, or capability
rule, to force a selective audit when that rule is matched. Audit
permissions accumulate just like standard permissions.
eg.
audit /bin/foo rw,
will force an audit message when the file /bin/foo is opened for
read or write.
audit /etc/shadow w,
/etc/shadow r,
will force an audit message when /etc/shadow is opened for writing.
The audit message is per permission bit so only opening the file
for read access will not, force an audit message.
audit can also be used in block form instead of prepending audit
to every rule.
audit {
/bin/foo rw,
/etc/shadow w,
}
/etc/shadow r, # don't audit r access to /etc/shadow
the deny key word can be prepended to file, network and capability
rules, to result in a denial of permissions when matching that rule.
The deny rule specifically does 3 things
- it gives AppArmor the ability to remember what has been denied
so that the tools don't prompt for what has been denied in
previous profiling sessions.
- it subtracts globally from the allowed permissions. Deny permissions
accumulate in the the deny set just as allow permissions accumulate
then, the deny set is subtracted from the allow set.
- it quiets known rejects. The default audit behavior of deny rules
is to quiet known rejects so that audit logs are not flooded
with already known rejects. To have known rejects logged prepend
the audit keyword to the deny rule. Deny rules do not have a
block form.
eg.
deny /foo/bar rw,
audit deny /etc/shadow w,
audit {
deny owner /blah w,
deny other /foo w,
deny /etc/shadow w,
}
2008-03-13 17:39:03 +00:00
|
|
|
* but invalid for regular x transitions
|
|
|
|
|
* sort it out later.
|
|
|
|
|
*/
|
|
|
|
|
mode |= AA_MAY_EXEC;
|
2006-04-11 21:52:54 +00:00
|
|
|
break;
|
|
|
|
|
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
/* error cases */
|
|
|
|
|
|
2006-04-11 21:52:54 +00:00
|
|
|
default:
|
2013-09-27 16:13:22 -07:00
|
|
|
lower = tolower(thisc);
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
switch (lower) {
|
|
|
|
|
case COD_READ_CHAR:
|
|
|
|
|
case COD_WRITE_CHAR:
|
2007-07-27 20:31:38 +00:00
|
|
|
case COD_APPEND_CHAR:
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
case COD_LINK_CHAR:
|
|
|
|
|
case COD_INHERIT_CHAR:
|
|
|
|
|
case COD_MMAP_CHAR:
|
|
|
|
|
case COD_EXEC_CHAR:
|
2013-09-27 16:13:22 -07:00
|
|
|
PDEBUG("Parsing mode: found invalid upper case char %c\n", thisc);
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
warn_uppercase();
|
2013-09-27 16:13:22 -07:00
|
|
|
thisc = lower;
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
goto reeval;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
yyerror(_("Internal: unexpected mode character '%c' in input"),
|
2013-09-27 16:13:22 -07:00
|
|
|
thisc);
|
[https://bugzilla.novell.com/show_bug.cgi?id=172061]
This (updated) patch to trunk adds support for Px and Ux (toggle
bprm_secure on exec) in the parser, As requested, lowercase p and u
corresponds to an unfiltered environmnet on exec, uppercase will filter
the environment. It applies after the 'm' patch.
As a side effect, I tried to reduce the use of hardcoded characters in
the debugging statements -- there are still a few warnings that have
hard coded letters in them; not sure I can fix them all.
This version issues a warning for every unsafe ux and issues a single
warning for the first 'R', 'W', 'X', 'L', and 'I' it encounters,
except when the "-q" or "--quiet" flag , "--remove" profile flag, or
"-N" report names flags are passed. Unfortunately, it made the logic
somewhat more convoluted. Wordsmithing improvements welcome.
2006-08-04 17:14:49 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
break;
|
2006-04-11 21:52:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
p++;
|
|
|
|
|
}
|
2007-11-29 18:06:53 +00:00
|
|
|
|
2006-04-11 21:52:54 +00:00
|
|
|
PDEBUG("Parsed mode: %s 0x%x\n", str_mode, mode);
|
|
|
|
|
|
|
|
|
|
return mode;
|
|
|
|
|
}
|
|
|
|
|
|
2007-11-16 09:35:31 +00:00
|
|
|
int parse_mode(const char *str_mode)
|
|
|
|
|
{
|
2007-11-29 18:06:53 +00:00
|
|
|
int tmp, mode = 0;
|
|
|
|
|
tmp = parse_sub_mode(str_mode, "");
|
|
|
|
|
mode = SHIFT_MODE(tmp, AA_USER_SHIFT);
|
|
|
|
|
mode |= SHIFT_MODE(tmp, AA_OTHER_SHIFT);
|
2007-11-16 09:35:31 +00:00
|
|
|
if (mode & ~AA_VALID_PERMS)
|
|
|
|
|
yyerror(_("Internal error generated invalid perm 0x%llx\n"), mode);
|
|
|
|
|
return mode;
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-02 12:58:54 -07:00
|
|
|
static int parse_X_sub_mode(const char *X, const char *str_mode, int *result, int fail, const char *mode_desc unused)
|
2014-04-07 03:19:19 -07:00
|
|
|
{
|
|
|
|
|
int mode = 0;
|
|
|
|
|
const char *p;
|
|
|
|
|
|
2015-03-02 09:50:14 -06:00
|
|
|
PDEBUG("Parsing %s mode: %s\n", X, str_mode);
|
2014-04-07 03:19:19 -07:00
|
|
|
|
|
|
|
|
if (!str_mode)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
p = str_mode;
|
|
|
|
|
while (*p) {
|
|
|
|
|
char current = *p;
|
|
|
|
|
char lower;
|
|
|
|
|
|
|
|
|
|
reeval:
|
|
|
|
|
switch (current) {
|
|
|
|
|
case COD_READ_CHAR:
|
|
|
|
|
PDEBUG("Parsing %s mode: found %s READ\n", X, mode_desc);
|
|
|
|
|
mode |= AA_DBUS_RECEIVE;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case COD_WRITE_CHAR:
|
|
|
|
|
PDEBUG("Parsing %s mode: found %s WRITE\n", X,
|
|
|
|
|
mode_desc);
|
|
|
|
|
mode |= AA_DBUS_SEND;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* error cases */
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
lower = tolower(current);
|
|
|
|
|
switch (lower) {
|
|
|
|
|
case COD_READ_CHAR:
|
|
|
|
|
case COD_WRITE_CHAR:
|
|
|
|
|
PDEBUG("Parsing %s mode: found invalid upper case char %c\n",
|
|
|
|
|
X, current);
|
|
|
|
|
warn_uppercase();
|
|
|
|
|
current = lower;
|
|
|
|
|
goto reeval;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
if (fail)
|
|
|
|
|
yyerror(_("Internal: unexpected %s mode character '%c' in input"),
|
|
|
|
|
X, current);
|
|
|
|
|
else
|
|
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
p++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
PDEBUG("Parsed %s mode: %s 0x%x\n", X, str_mode, mode);
|
|
|
|
|
|
|
|
|
|
*result = mode;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int parse_X_mode(const char *X, int valid, const char *str_mode, int *mode, int fail)
|
|
|
|
|
{
|
|
|
|
|
*mode = 0;
|
|
|
|
|
if (!parse_X_sub_mode(X, str_mode, mode, fail, ""))
|
|
|
|
|
return 0;
|
|
|
|
|
if (*mode & ~valid) {
|
|
|
|
|
if (fail)
|
|
|
|
|
yyerror(_("Internal error generated invalid %s perm 0x%x\n"),
|
|
|
|
|
X, mode);
|
|
|
|
|
else
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-27 16:13:22 -07:00
|
|
|
struct cod_entry *new_entry(char *ns, char *id, int mode, char *link_id)
|
2006-04-11 21:52:54 +00:00
|
|
|
{
|
|
|
|
|
struct cod_entry *entry = NULL;
|
|
|
|
|
|
Add Audit control to AppArmor through, the use of audit and deny
key words. Deny is also used to subtract permissions from the
profiles permission set.
the audit key word can be prepended to any file, network, or capability
rule, to force a selective audit when that rule is matched. Audit
permissions accumulate just like standard permissions.
eg.
audit /bin/foo rw,
will force an audit message when the file /bin/foo is opened for
read or write.
audit /etc/shadow w,
/etc/shadow r,
will force an audit message when /etc/shadow is opened for writing.
The audit message is per permission bit so only opening the file
for read access will not, force an audit message.
audit can also be used in block form instead of prepending audit
to every rule.
audit {
/bin/foo rw,
/etc/shadow w,
}
/etc/shadow r, # don't audit r access to /etc/shadow
the deny key word can be prepended to file, network and capability
rules, to result in a denial of permissions when matching that rule.
The deny rule specifically does 3 things
- it gives AppArmor the ability to remember what has been denied
so that the tools don't prompt for what has been denied in
previous profiling sessions.
- it subtracts globally from the allowed permissions. Deny permissions
accumulate in the the deny set just as allow permissions accumulate
then, the deny set is subtracted from the allow set.
- it quiets known rejects. The default audit behavior of deny rules
is to quiet known rejects so that audit logs are not flooded
with already known rejects. To have known rejects logged prepend
the audit keyword to the deny rule. Deny rules do not have a
block form.
eg.
deny /foo/bar rw,
audit deny /etc/shadow w,
audit {
deny owner /blah w,
deny other /foo w,
deny /etc/shadow w,
}
2008-03-13 17:39:03 +00:00
|
|
|
entry = (struct cod_entry *)calloc(1, sizeof(struct cod_entry));
|
2006-04-11 21:52:54 +00:00
|
|
|
if (!entry)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2013-09-27 16:13:22 -07:00
|
|
|
entry->ns = ns;
|
2007-11-16 09:18:48 +00:00
|
|
|
entry->name = id;
|
2007-11-16 09:37:31 +00:00
|
|
|
entry->link_name = link_id;
|
2007-06-26 21:10:28 +00:00
|
|
|
entry->mode = mode;
|
Add Audit control to AppArmor through, the use of audit and deny
key words. Deny is also used to subtract permissions from the
profiles permission set.
the audit key word can be prepended to any file, network, or capability
rule, to force a selective audit when that rule is matched. Audit
permissions accumulate just like standard permissions.
eg.
audit /bin/foo rw,
will force an audit message when the file /bin/foo is opened for
read or write.
audit /etc/shadow w,
/etc/shadow r,
will force an audit message when /etc/shadow is opened for writing.
The audit message is per permission bit so only opening the file
for read access will not, force an audit message.
audit can also be used in block form instead of prepending audit
to every rule.
audit {
/bin/foo rw,
/etc/shadow w,
}
/etc/shadow r, # don't audit r access to /etc/shadow
the deny key word can be prepended to file, network and capability
rules, to result in a denial of permissions when matching that rule.
The deny rule specifically does 3 things
- it gives AppArmor the ability to remember what has been denied
so that the tools don't prompt for what has been denied in
previous profiling sessions.
- it subtracts globally from the allowed permissions. Deny permissions
accumulate in the the deny set just as allow permissions accumulate
then, the deny set is subtracted from the allow set.
- it quiets known rejects. The default audit behavior of deny rules
is to quiet known rejects so that audit logs are not flooded
with already known rejects. To have known rejects logged prepend
the audit keyword to the deny rule. Deny rules do not have a
block form.
eg.
deny /foo/bar rw,
audit deny /etc/shadow w,
audit {
deny owner /blah w,
deny other /foo w,
deny /etc/shadow w,
}
2008-03-13 17:39:03 +00:00
|
|
|
entry->audit = 0;
|
2006-04-11 21:52:54 +00:00
|
|
|
entry->deny = FALSE;
|
|
|
|
|
|
|
|
|
|
entry->pattern_type = ePatternInvalid;
|
|
|
|
|
entry->pat.regex = NULL;
|
|
|
|
|
|
|
|
|
|
entry->next = NULL;
|
|
|
|
|
|
|
|
|
|
PDEBUG(" Insertion of: (%s)\n", entry->name);
|
|
|
|
|
return entry;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct cod_entry *copy_cod_entry(struct cod_entry *orig)
|
|
|
|
|
{
|
|
|
|
|
struct cod_entry *entry = NULL;
|
|
|
|
|
|
Add Audit control to AppArmor through, the use of audit and deny
key words. Deny is also used to subtract permissions from the
profiles permission set.
the audit key word can be prepended to any file, network, or capability
rule, to force a selective audit when that rule is matched. Audit
permissions accumulate just like standard permissions.
eg.
audit /bin/foo rw,
will force an audit message when the file /bin/foo is opened for
read or write.
audit /etc/shadow w,
/etc/shadow r,
will force an audit message when /etc/shadow is opened for writing.
The audit message is per permission bit so only opening the file
for read access will not, force an audit message.
audit can also be used in block form instead of prepending audit
to every rule.
audit {
/bin/foo rw,
/etc/shadow w,
}
/etc/shadow r, # don't audit r access to /etc/shadow
the deny key word can be prepended to file, network and capability
rules, to result in a denial of permissions when matching that rule.
The deny rule specifically does 3 things
- it gives AppArmor the ability to remember what has been denied
so that the tools don't prompt for what has been denied in
previous profiling sessions.
- it subtracts globally from the allowed permissions. Deny permissions
accumulate in the the deny set just as allow permissions accumulate
then, the deny set is subtracted from the allow set.
- it quiets known rejects. The default audit behavior of deny rules
is to quiet known rejects so that audit logs are not flooded
with already known rejects. To have known rejects logged prepend
the audit keyword to the deny rule. Deny rules do not have a
block form.
eg.
deny /foo/bar rw,
audit deny /etc/shadow w,
audit {
deny owner /blah w,
deny other /foo w,
deny /etc/shadow w,
}
2008-03-13 17:39:03 +00:00
|
|
|
entry = (struct cod_entry *)calloc(1, sizeof(struct cod_entry));
|
2006-04-11 21:52:54 +00:00
|
|
|
if (!entry)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2013-09-27 16:13:22 -07:00
|
|
|
DUP_STRING(orig, entry, ns, err);
|
2013-09-06 13:39:41 -07:00
|
|
|
DUP_STRING(orig, entry, name, err);
|
|
|
|
|
DUP_STRING(orig, entry, link_name, err);
|
2006-04-11 21:52:54 +00:00
|
|
|
entry->mode = orig->mode;
|
2010-02-12 13:46:55 -08:00
|
|
|
entry->audit = orig->audit;
|
2006-04-11 21:52:54 +00:00
|
|
|
entry->deny = orig->deny;
|
|
|
|
|
|
|
|
|
|
/* XXX - need to create copies of the patterns, too */
|
|
|
|
|
entry->pattern_type = orig->pattern_type;
|
|
|
|
|
entry->pat.regex = NULL;
|
|
|
|
|
|
|
|
|
|
entry->next = orig->next;
|
|
|
|
|
|
|
|
|
|
return entry;
|
2013-09-06 13:39:41 -07:00
|
|
|
|
|
|
|
|
err:
|
|
|
|
|
free_cod_entries(entry);
|
|
|
|
|
return NULL;
|
2006-04-11 21:52:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void free_cod_entries(struct cod_entry *list)
|
|
|
|
|
{
|
|
|
|
|
if (!list)
|
|
|
|
|
return;
|
|
|
|
|
if (list->next)
|
|
|
|
|
free_cod_entries(list->next);
|
2013-09-27 16:13:22 -07:00
|
|
|
if (list->ns)
|
|
|
|
|
free(list->ns);
|
2006-04-11 21:52:54 +00:00
|
|
|
if (list->name)
|
|
|
|
|
free(list->name);
|
2007-11-16 09:37:31 +00:00
|
|
|
if (list->link_name)
|
|
|
|
|
free(list->link_name);
|
2013-10-14 14:34:12 -07:00
|
|
|
if (list->nt_name)
|
|
|
|
|
free(list->nt_name);
|
2006-04-11 21:52:54 +00:00
|
|
|
if (list->pat.regex)
|
|
|
|
|
free(list->pat.regex);
|
|
|
|
|
free(list);
|
|
|
|
|
}
|
|
|
|
|
|
2007-11-16 09:35:31 +00:00
|
|
|
static void debug_base_perm_mask(int mask)
|
|
|
|
|
{
|
|
|
|
|
if (HAS_MAY_READ(mask))
|
|
|
|
|
printf("%c", COD_READ_CHAR);
|
|
|
|
|
if (HAS_MAY_WRITE(mask))
|
|
|
|
|
printf("%c", COD_WRITE_CHAR);
|
|
|
|
|
if (HAS_MAY_APPEND(mask))
|
|
|
|
|
printf("%c", COD_APPEND_CHAR);
|
|
|
|
|
if (HAS_MAY_LINK(mask))
|
|
|
|
|
printf("%c", COD_LINK_CHAR);
|
|
|
|
|
if (HAS_MAY_LOCK(mask))
|
|
|
|
|
printf("%c", COD_LOCK_CHAR);
|
|
|
|
|
if (HAS_EXEC_MMAP(mask))
|
|
|
|
|
printf("%c", COD_MMAP_CHAR);
|
|
|
|
|
if (HAS_MAY_EXEC(mask))
|
|
|
|
|
printf("%c", COD_EXEC_CHAR);
|
|
|
|
|
}
|
|
|
|
|
|
2006-04-11 21:52:54 +00:00
|
|
|
void debug_cod_entries(struct cod_entry *list)
|
|
|
|
|
{
|
|
|
|
|
struct cod_entry *item = NULL;
|
|
|
|
|
|
|
|
|
|
printf("--- Entries ---\n");
|
|
|
|
|
|
2007-02-27 02:29:16 +00:00
|
|
|
list_for_each(list, item) {
|
2006-04-11 21:52:54 +00:00
|
|
|
if (!item)
|
|
|
|
|
printf("Item is NULL!\n");
|
|
|
|
|
|
|
|
|
|
printf("Mode:\t");
|
2007-07-27 20:25:59 +00:00
|
|
|
if (HAS_CHANGE_PROFILE(item->mode))
|
|
|
|
|
printf(" change_profile");
|
2007-11-16 09:35:31 +00:00
|
|
|
if (HAS_EXEC_UNSAFE(item->mode))
|
|
|
|
|
printf(" unsafe");
|
|
|
|
|
debug_base_perm_mask(SHIFT_TO_BASE(item->mode, AA_USER_SHIFT));
|
|
|
|
|
printf(":");
|
|
|
|
|
debug_base_perm_mask(SHIFT_TO_BASE(item->mode, AA_OTHER_SHIFT));
|
2006-04-11 21:52:54 +00:00
|
|
|
if (item->name)
|
|
|
|
|
printf("\tName:\t(%s)\n", item->name);
|
|
|
|
|
else
|
|
|
|
|
printf("\tName:\tNULL\n");
|
2007-11-16 09:18:48 +00:00
|
|
|
|
2013-09-27 16:13:22 -07:00
|
|
|
if (item->ns)
|
|
|
|
|
printf("\tNs:\t(%s)\n", item->ns);
|
2007-11-16 09:18:48 +00:00
|
|
|
|
2007-11-16 09:37:31 +00:00
|
|
|
if (AA_LINK_BITS & item->mode)
|
|
|
|
|
printf("\tlink:\t(%s)\n", item->link_name ? item->link_name : "/**");
|
|
|
|
|
|
2006-04-11 21:52:54 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-03-12 19:23:27 +00:00
|
|
|
|
2006-04-11 21:52:54 +00:00
|
|
|
static const char *capnames[] = {
|
|
|
|
|
"chown",
|
|
|
|
|
"dac_override",
|
|
|
|
|
"dac_read_search",
|
|
|
|
|
"fowner",
|
|
|
|
|
"fsetid",
|
|
|
|
|
"kill",
|
|
|
|
|
"setgid",
|
|
|
|
|
"setuid",
|
|
|
|
|
"setpcap",
|
|
|
|
|
"linux_immutable",
|
|
|
|
|
"net_bind_service",
|
|
|
|
|
"net_broadcast",
|
|
|
|
|
"net_admin",
|
|
|
|
|
"net_raw",
|
|
|
|
|
"ipc_lock",
|
|
|
|
|
"ipc_owner",
|
|
|
|
|
"sys_module",
|
|
|
|
|
"sys_rawio",
|
|
|
|
|
"sys_chroot",
|
|
|
|
|
"sys_ptrace",
|
|
|
|
|
"sys_pacct",
|
|
|
|
|
"sys_admin",
|
|
|
|
|
"sys_boot",
|
|
|
|
|
"sys_nice",
|
|
|
|
|
"sys_resource",
|
|
|
|
|
"sys_time",
|
|
|
|
|
"sys_tty_config",
|
|
|
|
|
"mknod",
|
2006-11-08 10:43:11 +00:00
|
|
|
"lease",
|
|
|
|
|
"audit_write",
|
2009-08-20 15:27:12 +00:00
|
|
|
"audit_control",
|
|
|
|
|
"setfcap",
|
2016-01-16 11:26:52 +01:00
|
|
|
"mac_override",
|
2011-08-18 23:54:24 +02:00
|
|
|
"syslog",
|
2006-04-11 21:52:54 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const char *capability_to_name(unsigned int cap)
|
|
|
|
|
{
|
|
|
|
|
const char *capname;
|
|
|
|
|
|
|
|
|
|
capname = (cap < (sizeof(capnames) / sizeof(char *))
|
|
|
|
|
? capnames[cap] : "invalid-capability");
|
|
|
|
|
|
|
|
|
|
return capname;
|
|
|
|
|
}
|
|
|
|
|
|
2010-01-07 14:17:07 -08:00
|
|
|
void __debug_capabilities(uint64_t capset, const char *name)
|
|
|
|
|
{
|
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
|
|
printf("%s:", name);
|
|
|
|
|
for (i = 0; i < (sizeof(capnames)/sizeof(char *)); i++) {
|
|
|
|
|
if (((1ull << i) & capset) != 0) {
|
|
|
|
|
printf (" %s", capability_to_name(i));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
printf("\n");
|
|
|
|
|
}
|
|
|
|
|
|
2012-02-16 08:07:28 -08:00
|
|
|
struct value_list *new_value_list(char *value)
|
|
|
|
|
{
|
2013-09-27 16:13:22 -07:00
|
|
|
struct value_list *val = (struct value_list *) calloc(1, sizeof(struct value_list));
|
2012-02-16 08:07:28 -08:00
|
|
|
if (val)
|
|
|
|
|
val->value = value;
|
|
|
|
|
return val;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void free_value_list(struct value_list *list)
|
|
|
|
|
{
|
|
|
|
|
struct value_list *next;
|
|
|
|
|
|
|
|
|
|
while (list) {
|
|
|
|
|
next = list->next;
|
|
|
|
|
if (list->value)
|
|
|
|
|
free(list->value);
|
|
|
|
|
free(list);
|
|
|
|
|
list = next;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
Add mount rules
Add the ability to control mounting and unmounting
The basic form of the rules are.
[audit] [deny] mount [conds]* [device] [ -> [conds] path],
[audit] [deny] remount [conds]* [path],
[audit] [deny] umount [conds]* [path],
[audit] [deny] pivotroot [oldroot=<value>] <path> -> <profile>
remount is just a short cut for mount options=remount
where [conds] can be
fstype=<expr>
options=<expr>
conds follow the extended conditional syntax of allowing either:
* a single value after the equals, which has the same character range as
regular IDS (ie most anything but it can't be terminated with a , (comma)
and if spaces or other characters are needed it can be quoted
eg.
options=foo
options = foo
options="foo bar"
* a list of values after the equals, the list of values is enclosed within
parenthesis () and its has a slightly reduced character set but again
elements can be quoted.
the separation between elements is whitespace and commas.
eg.
options=(foo bar)
options=(foo, bar)
options=(foo , bar)
options=(foo,bar)
The rules are flexible and follow a similar pattern as network, capability,
etc.
mount, # allow all mounts, but not umount or pivotroot
mount fstype=procfs, # allow mounting procfs anywhere
mount options=(bind, ro) /foo -> /bar, # readonly bind mount
mount /dev/sda -> /mnt,
mount /dev/sd** -> /mnt/**,
mount fstype=overlayfs options=(rw,upperdir=/tmp/upper/,lowerdir=/) overlay -> /mnt/
umount,
umount /m*,
Currently variables and regexs are are supported on the device and mount
point. ie.
mount <devince> -> <mount point>,
Regexes are supported in fstype and options. The options have a further
caveat that regexs only work if the option is fs specific option.
eg. options=(upperdir=/tmp/*,lowerdir=/)
regex's will not currently work against the standard options like ro, rw
nosuid
Conditionals (fstype) can only be applied to the device (source) at this
time and will be disregarded in situations where the mount is manipulating
an existing mount (bind, remount).
Options can be specified multiple times
mount option=rw option=(nosuid,upperdir=/foo),
and will be combined together into a single set of values
The ordering of the standard mount options (rw,ro, ...) does not matter
but the ordering of fs specific options does.
Specifying that the value of a particular option does not matter can be
acheived by providing both the positive and negative forms of and option
option=(rw,ro) options=(suid,nosuid)
For the fs specific options specifying that a particular value does not
matter is achieve using a regex with alternations.
Improvements to the syntax and order restrictions are planned for the
future.
Signed-off-by: John Johansen <john.johansen@canonical.com>
2012-02-24 04:19:38 -08:00
|
|
|
struct value_list *dup_value_list(struct value_list *list)
|
|
|
|
|
{
|
|
|
|
|
struct value_list *entry, *dup, *head = NULL;
|
|
|
|
|
char *value;
|
|
|
|
|
|
|
|
|
|
list_for_each(list, entry) {
|
|
|
|
|
value = NULL;
|
|
|
|
|
if (list->value) {
|
|
|
|
|
value = strdup(list->value);
|
|
|
|
|
if (!value)
|
|
|
|
|
goto fail2;
|
|
|
|
|
}
|
|
|
|
|
dup = new_value_list(value);
|
|
|
|
|
if (!dup)
|
|
|
|
|
goto fail;
|
|
|
|
|
if (head)
|
|
|
|
|
list_append(head, dup);
|
|
|
|
|
else
|
|
|
|
|
head = dup;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return head;
|
|
|
|
|
|
|
|
|
|
fail:
|
|
|
|
|
free(value);
|
|
|
|
|
fail2:
|
|
|
|
|
free_value_list(head);
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2012-02-16 08:07:28 -08:00
|
|
|
void print_value_list(struct value_list *list)
|
|
|
|
|
{
|
|
|
|
|
struct value_list *entry;
|
|
|
|
|
|
|
|
|
|
if (!list)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
fprintf(stderr, "%s", list->value);
|
|
|
|
|
list = list->next;
|
|
|
|
|
list_for_each(list, entry) {
|
|
|
|
|
fprintf(stderr, ", %s", entry->value);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-23 11:36:26 -07:00
|
|
|
void move_conditional_value(const char *rulename, char **dst_ptr,
|
|
|
|
|
struct cond_entry *cond_ent)
|
|
|
|
|
{
|
|
|
|
|
if (*dst_ptr)
|
|
|
|
|
yyerror("%s conditional \"%s\" can only be specified once\n",
|
|
|
|
|
rulename, cond_ent->name);
|
|
|
|
|
|
|
|
|
|
*dst_ptr = cond_ent->vals->value;
|
|
|
|
|
cond_ent->vals->value = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-26 06:17:40 -07:00
|
|
|
struct cond_entry *new_cond_entry(char *name, int eq, struct value_list *list)
|
Add mount rules
Add the ability to control mounting and unmounting
The basic form of the rules are.
[audit] [deny] mount [conds]* [device] [ -> [conds] path],
[audit] [deny] remount [conds]* [path],
[audit] [deny] umount [conds]* [path],
[audit] [deny] pivotroot [oldroot=<value>] <path> -> <profile>
remount is just a short cut for mount options=remount
where [conds] can be
fstype=<expr>
options=<expr>
conds follow the extended conditional syntax of allowing either:
* a single value after the equals, which has the same character range as
regular IDS (ie most anything but it can't be terminated with a , (comma)
and if spaces or other characters are needed it can be quoted
eg.
options=foo
options = foo
options="foo bar"
* a list of values after the equals, the list of values is enclosed within
parenthesis () and its has a slightly reduced character set but again
elements can be quoted.
the separation between elements is whitespace and commas.
eg.
options=(foo bar)
options=(foo, bar)
options=(foo , bar)
options=(foo,bar)
The rules are flexible and follow a similar pattern as network, capability,
etc.
mount, # allow all mounts, but not umount or pivotroot
mount fstype=procfs, # allow mounting procfs anywhere
mount options=(bind, ro) /foo -> /bar, # readonly bind mount
mount /dev/sda -> /mnt,
mount /dev/sd** -> /mnt/**,
mount fstype=overlayfs options=(rw,upperdir=/tmp/upper/,lowerdir=/) overlay -> /mnt/
umount,
umount /m*,
Currently variables and regexs are are supported on the device and mount
point. ie.
mount <devince> -> <mount point>,
Regexes are supported in fstype and options. The options have a further
caveat that regexs only work if the option is fs specific option.
eg. options=(upperdir=/tmp/*,lowerdir=/)
regex's will not currently work against the standard options like ro, rw
nosuid
Conditionals (fstype) can only be applied to the device (source) at this
time and will be disregarded in situations where the mount is manipulating
an existing mount (bind, remount).
Options can be specified multiple times
mount option=rw option=(nosuid,upperdir=/foo),
and will be combined together into a single set of values
The ordering of the standard mount options (rw,ro, ...) does not matter
but the ordering of fs specific options does.
Specifying that the value of a particular option does not matter can be
acheived by providing both the positive and negative forms of and option
option=(rw,ro) options=(suid,nosuid)
For the fs specific options specifying that a particular value does not
matter is achieve using a regex with alternations.
Improvements to the syntax and order restrictions are planned for the
future.
Signed-off-by: John Johansen <john.johansen@canonical.com>
2012-02-24 04:19:38 -08:00
|
|
|
{
|
2013-09-27 16:13:22 -07:00
|
|
|
struct cond_entry *ent = (struct cond_entry *) calloc(1, sizeof(struct cond_entry));
|
Add mount rules
Add the ability to control mounting and unmounting
The basic form of the rules are.
[audit] [deny] mount [conds]* [device] [ -> [conds] path],
[audit] [deny] remount [conds]* [path],
[audit] [deny] umount [conds]* [path],
[audit] [deny] pivotroot [oldroot=<value>] <path> -> <profile>
remount is just a short cut for mount options=remount
where [conds] can be
fstype=<expr>
options=<expr>
conds follow the extended conditional syntax of allowing either:
* a single value after the equals, which has the same character range as
regular IDS (ie most anything but it can't be terminated with a , (comma)
and if spaces or other characters are needed it can be quoted
eg.
options=foo
options = foo
options="foo bar"
* a list of values after the equals, the list of values is enclosed within
parenthesis () and its has a slightly reduced character set but again
elements can be quoted.
the separation between elements is whitespace and commas.
eg.
options=(foo bar)
options=(foo, bar)
options=(foo , bar)
options=(foo,bar)
The rules are flexible and follow a similar pattern as network, capability,
etc.
mount, # allow all mounts, but not umount or pivotroot
mount fstype=procfs, # allow mounting procfs anywhere
mount options=(bind, ro) /foo -> /bar, # readonly bind mount
mount /dev/sda -> /mnt,
mount /dev/sd** -> /mnt/**,
mount fstype=overlayfs options=(rw,upperdir=/tmp/upper/,lowerdir=/) overlay -> /mnt/
umount,
umount /m*,
Currently variables and regexs are are supported on the device and mount
point. ie.
mount <devince> -> <mount point>,
Regexes are supported in fstype and options. The options have a further
caveat that regexs only work if the option is fs specific option.
eg. options=(upperdir=/tmp/*,lowerdir=/)
regex's will not currently work against the standard options like ro, rw
nosuid
Conditionals (fstype) can only be applied to the device (source) at this
time and will be disregarded in situations where the mount is manipulating
an existing mount (bind, remount).
Options can be specified multiple times
mount option=rw option=(nosuid,upperdir=/foo),
and will be combined together into a single set of values
The ordering of the standard mount options (rw,ro, ...) does not matter
but the ordering of fs specific options does.
Specifying that the value of a particular option does not matter can be
acheived by providing both the positive and negative forms of and option
option=(rw,ro) options=(suid,nosuid)
For the fs specific options specifying that a particular value does not
matter is achieve using a regex with alternations.
Improvements to the syntax and order restrictions are planned for the
future.
Signed-off-by: John Johansen <john.johansen@canonical.com>
2012-02-24 04:19:38 -08:00
|
|
|
if (ent) {
|
|
|
|
|
ent->name = name;
|
|
|
|
|
ent->vals = list;
|
2012-03-26 06:17:40 -07:00
|
|
|
ent->eq = eq;
|
Add mount rules
Add the ability to control mounting and unmounting
The basic form of the rules are.
[audit] [deny] mount [conds]* [device] [ -> [conds] path],
[audit] [deny] remount [conds]* [path],
[audit] [deny] umount [conds]* [path],
[audit] [deny] pivotroot [oldroot=<value>] <path> -> <profile>
remount is just a short cut for mount options=remount
where [conds] can be
fstype=<expr>
options=<expr>
conds follow the extended conditional syntax of allowing either:
* a single value after the equals, which has the same character range as
regular IDS (ie most anything but it can't be terminated with a , (comma)
and if spaces or other characters are needed it can be quoted
eg.
options=foo
options = foo
options="foo bar"
* a list of values after the equals, the list of values is enclosed within
parenthesis () and its has a slightly reduced character set but again
elements can be quoted.
the separation between elements is whitespace and commas.
eg.
options=(foo bar)
options=(foo, bar)
options=(foo , bar)
options=(foo,bar)
The rules are flexible and follow a similar pattern as network, capability,
etc.
mount, # allow all mounts, but not umount or pivotroot
mount fstype=procfs, # allow mounting procfs anywhere
mount options=(bind, ro) /foo -> /bar, # readonly bind mount
mount /dev/sda -> /mnt,
mount /dev/sd** -> /mnt/**,
mount fstype=overlayfs options=(rw,upperdir=/tmp/upper/,lowerdir=/) overlay -> /mnt/
umount,
umount /m*,
Currently variables and regexs are are supported on the device and mount
point. ie.
mount <devince> -> <mount point>,
Regexes are supported in fstype and options. The options have a further
caveat that regexs only work if the option is fs specific option.
eg. options=(upperdir=/tmp/*,lowerdir=/)
regex's will not currently work against the standard options like ro, rw
nosuid
Conditionals (fstype) can only be applied to the device (source) at this
time and will be disregarded in situations where the mount is manipulating
an existing mount (bind, remount).
Options can be specified multiple times
mount option=rw option=(nosuid,upperdir=/foo),
and will be combined together into a single set of values
The ordering of the standard mount options (rw,ro, ...) does not matter
but the ordering of fs specific options does.
Specifying that the value of a particular option does not matter can be
acheived by providing both the positive and negative forms of and option
option=(rw,ro) options=(suid,nosuid)
For the fs specific options specifying that a particular value does not
matter is achieve using a regex with alternations.
Improvements to the syntax and order restrictions are planned for the
future.
Signed-off-by: John Johansen <john.johansen@canonical.com>
2012-02-24 04:19:38 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ent;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void free_cond_entry(struct cond_entry *ent)
|
|
|
|
|
{
|
|
|
|
|
if (ent) {
|
|
|
|
|
free(ent->name);
|
|
|
|
|
free_value_list(ent->vals);
|
|
|
|
|
free(ent);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-07-31 09:05:51 -07:00
|
|
|
void free_cond_list(struct cond_entry *ents)
|
|
|
|
|
{
|
|
|
|
|
struct cond_entry *entry, *tmp;
|
|
|
|
|
|
|
|
|
|
list_for_each_safe(ents, entry, tmp) {
|
|
|
|
|
free_cond_entry(entry);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
Add mount rules
Add the ability to control mounting and unmounting
The basic form of the rules are.
[audit] [deny] mount [conds]* [device] [ -> [conds] path],
[audit] [deny] remount [conds]* [path],
[audit] [deny] umount [conds]* [path],
[audit] [deny] pivotroot [oldroot=<value>] <path> -> <profile>
remount is just a short cut for mount options=remount
where [conds] can be
fstype=<expr>
options=<expr>
conds follow the extended conditional syntax of allowing either:
* a single value after the equals, which has the same character range as
regular IDS (ie most anything but it can't be terminated with a , (comma)
and if spaces or other characters are needed it can be quoted
eg.
options=foo
options = foo
options="foo bar"
* a list of values after the equals, the list of values is enclosed within
parenthesis () and its has a slightly reduced character set but again
elements can be quoted.
the separation between elements is whitespace and commas.
eg.
options=(foo bar)
options=(foo, bar)
options=(foo , bar)
options=(foo,bar)
The rules are flexible and follow a similar pattern as network, capability,
etc.
mount, # allow all mounts, but not umount or pivotroot
mount fstype=procfs, # allow mounting procfs anywhere
mount options=(bind, ro) /foo -> /bar, # readonly bind mount
mount /dev/sda -> /mnt,
mount /dev/sd** -> /mnt/**,
mount fstype=overlayfs options=(rw,upperdir=/tmp/upper/,lowerdir=/) overlay -> /mnt/
umount,
umount /m*,
Currently variables and regexs are are supported on the device and mount
point. ie.
mount <devince> -> <mount point>,
Regexes are supported in fstype and options. The options have a further
caveat that regexs only work if the option is fs specific option.
eg. options=(upperdir=/tmp/*,lowerdir=/)
regex's will not currently work against the standard options like ro, rw
nosuid
Conditionals (fstype) can only be applied to the device (source) at this
time and will be disregarded in situations where the mount is manipulating
an existing mount (bind, remount).
Options can be specified multiple times
mount option=rw option=(nosuid,upperdir=/foo),
and will be combined together into a single set of values
The ordering of the standard mount options (rw,ro, ...) does not matter
but the ordering of fs specific options does.
Specifying that the value of a particular option does not matter can be
acheived by providing both the positive and negative forms of and option
option=(rw,ro) options=(suid,nosuid)
For the fs specific options specifying that a particular value does not
matter is achieve using a regex with alternations.
Improvements to the syntax and order restrictions are planned for the
future.
Signed-off-by: John Johansen <john.johansen@canonical.com>
2012-02-24 04:19:38 -08:00
|
|
|
void print_cond_entry(struct cond_entry *ent)
|
|
|
|
|
{
|
|
|
|
|
if (ent) {
|
|
|
|
|
fprintf(stderr, "%s=(", ent->name);
|
|
|
|
|
print_value_list(ent->vals);
|
|
|
|
|
fprintf(stderr, ")\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-10 18:16:09 -07:00
|
|
|
|
|
|
|
|
struct time_units {
|
|
|
|
|
const char *str;
|
|
|
|
|
long long value;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct time_units time_units[] = {
|
|
|
|
|
{ "us", 1LL },
|
|
|
|
|
{ "microsecond", 1LL },
|
|
|
|
|
{ "microseconds", 1LL },
|
|
|
|
|
{ "ms", 1000LL },
|
|
|
|
|
{ "millisecond", 1000LL },
|
|
|
|
|
{ "milliseconds", 1000LL },
|
|
|
|
|
{ "s", 1000LL * 1000LL },
|
|
|
|
|
{ "sec", SECONDS_P_MS },
|
|
|
|
|
{ "second", SECONDS_P_MS },
|
|
|
|
|
{ "seconds", SECONDS_P_MS },
|
|
|
|
|
{ "min" , 60LL * SECONDS_P_MS },
|
|
|
|
|
{ "minute", 60LL * SECONDS_P_MS },
|
|
|
|
|
{ "minutes", 60LL * SECONDS_P_MS },
|
|
|
|
|
{ "h", 60LL * 60LL * SECONDS_P_MS },
|
|
|
|
|
{ "hour", 60LL * 60LL * SECONDS_P_MS },
|
|
|
|
|
{ "hours", 60LL * 60LL * SECONDS_P_MS },
|
|
|
|
|
{ "d", 24LL * 60LL * 60LL * SECONDS_P_MS },
|
|
|
|
|
{ "day", 24LL * 60LL * 60LL * SECONDS_P_MS },
|
|
|
|
|
{ "days", 24LL * 60LL * 60LL * SECONDS_P_MS },
|
|
|
|
|
{ "week", 7LL * 24LL * 60LL * 60LL * SECONDS_P_MS },
|
|
|
|
|
{ "weeks", 7LL * 24LL * 60LL * 60LL * SECONDS_P_MS },
|
|
|
|
|
{ NULL, 0 }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
long long convert_time_units(long long value, long long base, const char *units)
|
|
|
|
|
{
|
|
|
|
|
struct time_units *ent;
|
|
|
|
|
if (!units)
|
|
|
|
|
/* default to base if no units */
|
|
|
|
|
return value;
|
|
|
|
|
|
|
|
|
|
for (ent = time_units; ent->str; ent++) {
|
|
|
|
|
if (strcmp(ent->str, units) == 0) {
|
|
|
|
|
if (value * ent->value < base)
|
|
|
|
|
return -1LL;
|
|
|
|
|
return value * ent->value / base;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return -2LL;
|
|
|
|
|
}
|
|
|
|
|
|
2006-04-11 21:52:54 +00:00
|
|
|
#ifdef UNIT_TEST
|
2013-09-27 16:16:37 -07:00
|
|
|
|
|
|
|
|
#include "unit_test.h"
|
|
|
|
|
|
2006-04-11 21:52:54 +00:00
|
|
|
int test_str_to_boolean(void)
|
|
|
|
|
{
|
|
|
|
|
int rc = 0;
|
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
|
|
retval = str_to_boolean("TRUE");
|
|
|
|
|
MY_TEST(retval == 1, "str2bool for TRUE");
|
|
|
|
|
|
|
|
|
|
retval = str_to_boolean("TrUe");
|
|
|
|
|
MY_TEST(retval == 1, "str2bool for TrUe");
|
|
|
|
|
|
|
|
|
|
retval = str_to_boolean("false");
|
|
|
|
|
MY_TEST(retval == 0, "str2bool for false");
|
|
|
|
|
|
|
|
|
|
retval = str_to_boolean("flase");
|
|
|
|
|
MY_TEST(retval == -1, "str2bool for flase");
|
|
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
2010-03-08 20:38:54 -08:00
|
|
|
|
|
|
|
|
int test_processunquoted(void)
|
|
|
|
|
{
|
|
|
|
|
int rc = 0;
|
2014-04-15 14:59:41 -07:00
|
|
|
const char *teststring;
|
|
|
|
|
const char *resultstring;
|
2010-03-08 20:38:54 -08:00
|
|
|
|
|
|
|
|
teststring = "";
|
|
|
|
|
MY_TEST(strcmp(teststring, processunquoted(teststring, strlen(teststring))) == 0,
|
|
|
|
|
"processunquoted on empty string");
|
|
|
|
|
|
2014-04-15 14:59:41 -07:00
|
|
|
teststring = "\\1";
|
|
|
|
|
resultstring = "\001";
|
|
|
|
|
MY_TEST(strcmp(resultstring, processunquoted(teststring, strlen(teststring))) == 0,
|
|
|
|
|
"processunquoted on one digit octal");
|
|
|
|
|
|
|
|
|
|
teststring = "\\8";
|
|
|
|
|
resultstring = "\\8";
|
|
|
|
|
MY_TEST(strcmp(resultstring, processunquoted(teststring, strlen(teststring))) == 0,
|
|
|
|
|
"processunquoted on invalid octal digit \\8");
|
|
|
|
|
|
|
|
|
|
teststring = "\\18";
|
|
|
|
|
resultstring = "\0018";
|
|
|
|
|
MY_TEST(strcmp(resultstring, processunquoted(teststring, strlen(teststring))) == 0,
|
|
|
|
|
"processunquoted on one digit octal followed by invalid octal digit");
|
|
|
|
|
|
|
|
|
|
teststring = "\\1a";
|
|
|
|
|
resultstring = "\001a";
|
|
|
|
|
MY_TEST(strcmp(resultstring, processunquoted(teststring, strlen(teststring))) == 0,
|
|
|
|
|
"processunquoted on one digit octal followed by hex digit a");
|
|
|
|
|
|
|
|
|
|
teststring = "\\1z";
|
|
|
|
|
resultstring = "\001z";
|
|
|
|
|
MY_TEST(strcmp(resultstring, processunquoted(teststring, strlen(teststring))) == 0,
|
|
|
|
|
"processunquoted on one digit octal follow by char z");
|
|
|
|
|
|
|
|
|
|
teststring = "\\11";
|
|
|
|
|
resultstring = "\011";
|
|
|
|
|
MY_TEST(strcmp(resultstring, processunquoted(teststring, strlen(teststring))) == 0,
|
|
|
|
|
"processunquoted on two digit octal");
|
|
|
|
|
|
|
|
|
|
teststring = "\\118";
|
|
|
|
|
resultstring = "\0118";
|
|
|
|
|
MY_TEST(strcmp(resultstring, processunquoted(teststring, strlen(teststring))) == 0,
|
|
|
|
|
"processunquoted on two digit octal followed by invalid octal digit");
|
|
|
|
|
|
|
|
|
|
teststring = "\\11a";
|
|
|
|
|
resultstring = "\011a";
|
|
|
|
|
MY_TEST(strcmp(resultstring, processunquoted(teststring, strlen(teststring))) == 0,
|
|
|
|
|
"processunquoted on two digit octal followed by hex digit a");
|
|
|
|
|
|
|
|
|
|
teststring = "\\11z";
|
|
|
|
|
resultstring = "\011z";
|
|
|
|
|
MY_TEST(strcmp(resultstring, processunquoted(teststring, strlen(teststring))) == 0,
|
|
|
|
|
"processunquoted on two digit octal followed by char z");
|
|
|
|
|
|
|
|
|
|
teststring = "\\111";
|
|
|
|
|
resultstring = "\111";
|
|
|
|
|
MY_TEST(strcmp(resultstring, processunquoted(teststring, strlen(teststring))) == 0,
|
|
|
|
|
"processunquoted on three digit octal");
|
|
|
|
|
|
|
|
|
|
teststring = "\\378";
|
|
|
|
|
resultstring = "\0378";
|
|
|
|
|
MY_TEST(strcmp(resultstring, processunquoted(teststring, strlen(teststring))) == 0,
|
|
|
|
|
"processunquoted on three digit octal two large, taken as 2 digit octal plus trailing char");
|
|
|
|
|
|
2010-03-08 20:38:54 -08:00
|
|
|
teststring = "123\\421123";
|
2014-04-15 14:59:41 -07:00
|
|
|
resultstring = "123\0421123";
|
|
|
|
|
MY_TEST(strcmp(resultstring, processunquoted(teststring, strlen(teststring))) == 0,
|
|
|
|
|
"processunquoted on two character octal followed by valid octal digit \\421");
|
2010-03-08 20:38:54 -08:00
|
|
|
|
|
|
|
|
teststring = "123\\109123";
|
2014-04-15 14:59:41 -07:00
|
|
|
resultstring = "123\109123";
|
|
|
|
|
MY_TEST(strcmp(resultstring, processunquoted(teststring, strlen(teststring))) == 0,
|
|
|
|
|
"processunquoted on octal 109");
|
|
|
|
|
|
|
|
|
|
teststring = "123\\1089123";
|
|
|
|
|
resultstring = "123\1089123";
|
|
|
|
|
MY_TEST(strcmp(resultstring, processunquoted(teststring, strlen(teststring))) == 0,
|
|
|
|
|
"processunquoted on octal 108");
|
2010-03-08 20:38:54 -08:00
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
2011-04-05 20:55:19 -07:00
|
|
|
int test_processquoted(void)
|
|
|
|
|
{
|
|
|
|
|
int rc = 0;
|
2013-10-01 10:59:04 -07:00
|
|
|
const char *teststring, *processedstring;
|
2011-04-05 20:55:19 -07:00
|
|
|
char *out;
|
|
|
|
|
|
|
|
|
|
teststring = "";
|
|
|
|
|
out = processquoted(teststring, strlen(teststring));
|
|
|
|
|
MY_TEST(strcmp(teststring, out) == 0,
|
|
|
|
|
"processquoted on empty string");
|
|
|
|
|
free(out);
|
|
|
|
|
|
|
|
|
|
teststring = "\"abcdefg\"";
|
|
|
|
|
processedstring = "abcdefg";
|
|
|
|
|
out = processquoted(teststring, strlen(teststring));
|
|
|
|
|
MY_TEST(strcmp(processedstring, out) == 0,
|
|
|
|
|
"processquoted on simple string");
|
|
|
|
|
free(out);
|
|
|
|
|
|
|
|
|
|
teststring = "\"abcd\\tefg\"";
|
|
|
|
|
processedstring = "abcd\tefg";
|
|
|
|
|
out = processquoted(teststring, strlen(teststring));
|
|
|
|
|
MY_TEST(strcmp(processedstring, out) == 0,
|
|
|
|
|
"processquoted on string with tab");
|
|
|
|
|
free(out);
|
|
|
|
|
|
|
|
|
|
teststring = "\"abcdefg\\\"";
|
|
|
|
|
processedstring = "abcdefg\\";
|
|
|
|
|
out = processquoted(teststring, strlen(teststring));
|
|
|
|
|
MY_TEST(strcmp(processedstring, out) == 0,
|
|
|
|
|
"processquoted on trailing slash");
|
|
|
|
|
free(out);
|
|
|
|
|
|
|
|
|
|
teststring = "\"a\\\\bcdefg\"";
|
2014-06-19 13:50:57 -07:00
|
|
|
processedstring = "a\\\\bcdefg";
|
2011-04-05 20:55:19 -07:00
|
|
|
out = processquoted(teststring, strlen(teststring));
|
|
|
|
|
MY_TEST(strcmp(processedstring, out) == 0,
|
|
|
|
|
"processquoted on quoted slash");
|
|
|
|
|
free(out);
|
|
|
|
|
|
|
|
|
|
teststring = "\"a\\\"bcde\\\"fg\"";
|
|
|
|
|
processedstring = "a\"bcde\"fg";
|
|
|
|
|
out = processquoted(teststring, strlen(teststring));
|
|
|
|
|
MY_TEST(strcmp(processedstring, out) == 0,
|
|
|
|
|
"processquoted on quoted quotes");
|
|
|
|
|
free(out);
|
|
|
|
|
|
|
|
|
|
teststring = "\"\\rabcdefg\"";
|
|
|
|
|
processedstring = "\rabcdefg";
|
|
|
|
|
out = processquoted(teststring, strlen(teststring));
|
|
|
|
|
MY_TEST(strcmp(processedstring, out) == 0,
|
|
|
|
|
"processquoted on quoted \\r");
|
|
|
|
|
free(out);
|
|
|
|
|
|
|
|
|
|
teststring = "\"abcdefg\\n\"";
|
|
|
|
|
processedstring = "abcdefg\n";
|
|
|
|
|
out = processquoted(teststring, strlen(teststring));
|
|
|
|
|
MY_TEST(strcmp(processedstring, out) == 0,
|
|
|
|
|
"processquoted on quoted \\n");
|
|
|
|
|
free(out);
|
|
|
|
|
|
|
|
|
|
teststring = "\"\\Uabc\\Ndefg\\x\"";
|
|
|
|
|
processedstring = "\\Uabc\\Ndefg\\x";
|
|
|
|
|
out = processquoted(teststring, strlen(teststring));
|
|
|
|
|
MY_TEST(strcmp(processedstring, out) == 0,
|
|
|
|
|
"processquoted passthrough on invalid quoted chars");
|
|
|
|
|
free(out);
|
|
|
|
|
|
|
|
|
|
teststring = "\"abc\\042defg\"";
|
|
|
|
|
processedstring = "abc\"defg";
|
|
|
|
|
out = processquoted(teststring, strlen(teststring));
|
|
|
|
|
MY_TEST(strcmp(processedstring, out) == 0,
|
|
|
|
|
"processquoted on quoted octal \\042");
|
|
|
|
|
free(out);
|
|
|
|
|
|
|
|
|
|
teststring = "\"abcdefg\\176\"";
|
|
|
|
|
processedstring = "abcdefg~";
|
|
|
|
|
out = processquoted(teststring, strlen(teststring));
|
|
|
|
|
MY_TEST(strcmp(processedstring, out) == 0,
|
|
|
|
|
"processquoted on quoted octal \\176");
|
|
|
|
|
free(out);
|
|
|
|
|
|
2014-04-15 14:59:41 -07:00
|
|
|
teststring = "\"abc\\429defg\"";
|
|
|
|
|
processedstring = "abc\0429defg";
|
2011-04-05 20:55:19 -07:00
|
|
|
out = processquoted(teststring, strlen(teststring));
|
|
|
|
|
MY_TEST(strcmp(processedstring, out) == 0,
|
2014-04-15 14:59:41 -07:00
|
|
|
"processquoted passthrough quoted invalid octal \\429");
|
2011-04-05 20:55:19 -07:00
|
|
|
free(out);
|
|
|
|
|
|
2014-04-15 14:59:41 -07:00
|
|
|
teststring = "\"abcdefg\\4\"";
|
|
|
|
|
processedstring = "abcdefg\004";
|
|
|
|
|
out = processquoted(teststring, strlen(teststring));
|
|
|
|
|
MY_TEST(strcmp(processedstring, out) == 0,
|
|
|
|
|
"processquoted passthrough quoted one digit trailing octal \\4");
|
|
|
|
|
|
2011-04-05 20:55:19 -07:00
|
|
|
teststring = "\"abcdefg\\04\"";
|
2014-04-15 14:59:41 -07:00
|
|
|
processedstring = "abcdefg\004";
|
|
|
|
|
out = processquoted(teststring, strlen(teststring));
|
|
|
|
|
MY_TEST(strcmp(processedstring, out) == 0,
|
|
|
|
|
"processquoted passthrough quoted two digit trailing octal \\04");
|
|
|
|
|
|
|
|
|
|
teststring = "\"abcdefg\\004\"";
|
|
|
|
|
processedstring = "abcdefg\004";
|
2011-04-05 20:55:19 -07:00
|
|
|
out = processquoted(teststring, strlen(teststring));
|
|
|
|
|
MY_TEST(strcmp(processedstring, out) == 0,
|
2014-04-15 14:59:41 -07:00
|
|
|
"processquoted passthrough quoted three digit trailing octal \\004");
|
2011-04-05 20:55:19 -07:00
|
|
|
free(out);
|
|
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-10 18:16:09 -07:00
|
|
|
#define TIME_TEST(V, B, U, R) \
|
|
|
|
|
MY_TEST(convert_time_units((V), (B), U) == (R), \
|
|
|
|
|
"convert " #V " with base of " #B ", " #U " units")
|
|
|
|
|
|
|
|
|
|
int test_convert_time_units()
|
|
|
|
|
{
|
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
|
|
TIME_TEST(1LL, 1LL, NULL, 1LL);
|
|
|
|
|
TIME_TEST(12345LL, 1LL, NULL, 12345LL);
|
|
|
|
|
TIME_TEST(10LL, 10LL, NULL, 10LL);
|
|
|
|
|
TIME_TEST(123450LL, 10LL, NULL, 123450LL);
|
|
|
|
|
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "us", 12345LL);
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "microsecond", 12345LL);
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "microseconds", 12345LL);
|
|
|
|
|
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "ms", 12345LL*1000LL);
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "millisecond", 12345LL*1000LL);
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "milliseconds", 12345LL*1000LL);
|
|
|
|
|
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "s", 12345LL*1000LL*1000LL);
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "sec", 12345LL*1000LL*1000LL);
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "second", 12345LL*1000LL*1000LL);
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "seconds", 12345LL*1000LL*1000LL);
|
|
|
|
|
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "min", 12345LL*1000LL*1000LL*60LL);
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "minute", 12345LL*1000LL*1000LL*60LL);
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "minutes", 12345LL*1000LL*1000LL*60LL);
|
|
|
|
|
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "h", 12345LL*1000LL*1000LL*60LL*60LL);
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "hour", 12345LL*1000LL*1000LL*60LL*60LL);
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "hours", 12345LL*1000LL*1000LL*60LL*60LL);
|
|
|
|
|
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "d", 12345LL*1000LL*1000LL*60LL*60LL*24LL);
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "day", 12345LL*1000LL*1000LL*60LL*60LL*24LL);
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "days", 12345LL*1000LL*1000LL*60LL*60LL*24LL);
|
|
|
|
|
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "week", 12345LL*1000LL*1000LL*60LL*60LL*24LL*7LL);
|
|
|
|
|
TIME_TEST(12345LL, 1LL, "weeks", 12345LL*1000LL*1000LL*60LL*60LL*24LL*7LL);
|
|
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
2006-04-11 21:52:54 +00:00
|
|
|
int main(void)
|
|
|
|
|
{
|
|
|
|
|
int rc = 0;
|
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
|
|
retval = test_str_to_boolean();
|
|
|
|
|
if (retval != 0)
|
|
|
|
|
rc = retval;
|
|
|
|
|
|
2010-03-08 20:38:54 -08:00
|
|
|
retval = test_processunquoted();
|
|
|
|
|
if (retval != 0)
|
|
|
|
|
rc = retval;
|
2011-04-05 20:55:19 -07:00
|
|
|
|
|
|
|
|
retval = test_processquoted();
|
|
|
|
|
if (retval != 0)
|
|
|
|
|
rc = retval;
|
|
|
|
|
|
2015-07-10 18:16:09 -07:00
|
|
|
retval = test_convert_time_units();
|
|
|
|
|
if (retval != 0)
|
|
|
|
|
rc = retval;
|
|
|
|
|
|
2006-04-11 21:52:54 +00:00
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
#endif /* UNIT_TEST */
|