sudoers - Cheap VPS LLC

SUDOERS


Section: File Formats (5)
Index
Return to Main Contents


BSD mandoc

Sudo 1.8.6p3

 

NAME

sudoers

– default sudo security policy module

 

DESCRIPTION

The
sudoers

policy module determines a user’s
sudo

privileges.
It is the default
sudo

policy plugin.
The policy is driven by
the
/etc/sudoers

file or, optionally in LDAP.
The policy format is described in detail in the
Sx SUDOERS FILE FORMAT

section.
For information on storing
sudoers

policy information
in LDAP, please see
sudoers.ldap5.

 

Authentication and logging

The
sudoers

security policy requires that most users authenticate
themselves before they can use
sudo

A password is not required
if the invoking user is root, if the target user is the same as the
invoking user, or if the policy has disabled authentication for the
user or command.
Unlike
su(1),

when
sudoers

requires
authentication, it validates the invoking user’s credentials, not
the target user’s (or root’s) credentials.
This can be changed via
the
rootpw

targetpw

and
runaspw

flags, described later.

If a user who is not listed in the policy tries to run a command
via
sudo

mail is sent to the proper authorities.
The address
used for such mail is configurable via the
mailto

Defaults entry
(described later) and defaults to
root

Note that mail will not be sent if an unauthorized user tries to
run
sudo

with the
-l

or
-v

option.
This allows users to
determine for themselves whether or not they are allowed to use
sudo

If
sudo

is run by root and the
SUDO_USER

environment variable
is set, the
sudoers

policy will use this value to determine who
the actual user is.
This can be used by a user to log commands
through sudo even when a root shell has been invoked.
It also
allows the
-e

option to remain useful even when invoked via a
sudo-run script or program.
Note, however, that the
sudoers

lookup is still done for root, not the user specified by
SUDO_USER

sudoers

uses time stamp files for credential caching.
Once a
user has been authenticated, the time stamp is updated and the user
may then use sudo without a password for a short period of time
Po 5

minutes unless overridden by the
timeout

option
Pc .

By default,
sudoers

uses a tty-based time stamp which means that
there is a separate time stamp for each of a user’s login sessions.
The
tty_tickets

option can be disabled to force the use of a
single time stamp for all of a user’s sessions.

sudoers

can log both successful and unsuccessful attempts (as well
as errors) to
syslog(3),

a log file, or both.
By default,
sudoers

will log via
syslog(3)

but this is changeable via the
syslog

and
logfile

Defaults settings.

sudoers

also supports logging a command’s input and output
streams.
I/O logging is not on by default but can be enabled using
the
log_input

and
log_output

Defaults flags as well as the
LOG_INPUT

and
LOG_OUTPUT

command tags.
 

Command environment

Since environment variables can influence program behavior,
sudoers

provides a means to restrict which variables from the user’s
environment are inherited by the command to be run.
There are two
distinct ways
sudoers

can deal with environment variables.

By default, the
env_reset

option is enabled.
This causes commands
to be executed with a new, minimal environment.
On AIX (and Linux
systems without PAM), the environment is initialized with the
contents of the
/etc/environment

file.
The new environment contains the
TERM

PATH

HOME

MAIL

SHELL

LOGNAME

USER

USERNAME

and
SUDO_*

variables
in addition to variables from the invoking process permitted by the
env_check

and
env_keep

options.
This is effectively a whitelist
for environment variables.

If, however, the
env_reset

option is disabled, any variables not
explicitly denied by the
env_check

and
env_delete

options are
inherited from the invoking process.
In this case,
env_check

and
env_delete

behave like a blacklist.
Since it is not possible
to blacklist all potentially dangerous environment variables, use
of the default
env_reset

behavior is encouraged.

In all cases, environment variables with a value beginning with
()

are removed as they could be interpreted as
bash

functions.
The list of environment variables that
sudo

allows or denies is
contained in the output of
sudo -V

when run as root.

Note that the dynamic linker on most operating systems will remove
variables that can control dynamic linking from the environment of
setuid executables, including
sudo

Depending on the operating
system this may include
_RLD*

DYLD_*

LD_*

LDR_*

LIBPATH

SHLIB_PATH

and others.
These type of variables are
removed from the environment before
sudo

even begins execution
and, as such, it is not possible for
sudo

to preserve them.

As a special case, if
sudo ‘s

-i

option (initial login) is
specified,
sudoers

will initialize the environment regardless
of the value of
env_reset

The
DISPLAY

PATH

and
TERM

variables remain unchanged;
HOME

MAIL

SHELL

USER

and
LOGNAME

are set based on the target user.
On AIX (and Linux
systems without PAM), the contents of
/etc/environment

are also
included.
All other environment variables are removed.

Finally, if the
env_file

option is defined, any variables present
in that file will be set to their specified values as long as they
would not conflict with an existing environment variable.
 

SUDOERS FILE FORMAT

The
sudoers

file is composed of two types of entries: aliases
(basically variables) and user specifications (which specify who
may run what).

When multiple entries match for a user, they are applied in order.
Where there are multiple matches, the last match is used (which is
not necessarily the most specific match).

The
sudoers

grammar will be described below in Extended Backus-Naur
Form (EBNF).
Don’t despair if you are unfamiliar with EBNF; it is fairly simple,
and the definitions below are annotated.
 

Quick guide to EBNF

EBNF is a concise and exact way of describing the grammar of a language.
Each EBNF definition is made up of
production rules

E.g.,

symbol ::= definition | alternate1 | alternate2 …

Each
production rule

references others and thus makes up a
grammar for the language.
EBNF also contains the following
operators, which many readers will recognize from regular
expressions.
Do not, however, confuse them with
“wildcard”

characters, which have different meanings.


?


Means that the preceding symbol (or group of symbols) is optional.
That is, it may appear once or not at all.
*


Means that the preceding symbol (or group of symbols) may appear
zero or more times.
+


Means that the preceding symbol (or group of symbols) may appear
one or more times.

Parentheses may be used to group symbols together.
For clarity,
we will use single quotes
(”)

to designate what is a verbatim character string (as opposed to a symbol name).
 

Aliases

There are four kinds of aliases:
User_Alias

Runas_Alias

Host_Alias

and
Cmnd_Alias


Alias ::= ‘User_Alias’ User_Alias (‘:’ User_Alias)* |
‘Runas_Alias’ Runas_Alias (‘:’ Runas_Alias)* |
‘Host_Alias’ Host_Alias (‘:’ Host_Alias)* |
‘Cmnd_Alias’ Cmnd_Alias (‘:’ Cmnd_Alias)*

User_Alias ::= NAME ‘=’ User_List

Runas_Alias ::= NAME ‘=’ Runas_List

Host_Alias ::= NAME ‘=’ Host_List

Cmnd_Alias ::= NAME ‘=’ Cmnd_List

NAME ::= [A-Z]([A-Z][0-9]_)*

Each
alias

definition is of the form


Alias_Type NAME = item1, item2, …

where
Alias_Type

is one of
User_Alias

Runas_Alias

Host_Alias

or
Cmnd_Alias

A
NAME

is a string of uppercase letters, numbers,
and underscore characters
(`_’

)

A
NAME

must

start with an
uppercase letter.
It is possible to put several alias definitions
of the same type on a single line, joined by a colon
(`:’

)

E.g.,


Alias_Type NAME = item1, item2, item3 : NAME = item4, item5

The definitions of what constitutes a valid
alias

member follow.


User_List ::= User |
User ‘,’ User_List

User ::= ‘!’* user name |
‘!’* #uid |
‘!’* %group |
‘!’* %#gid |
‘!’* +netgroup |
‘!’* %:nonunix_group |
‘!’* %:#nonunix_gid |
‘!’* User_Alias

A
User_List

is made up of one or more user names, user ids
(prefixed with
`#’

) ,
system group names and ids (prefixed with
`%’

and
`%#’

respectively), netgroups (prefixed with
`+’

) ,
non-Unix group names and IDs (prefixed with
`%:’

and
`%:#’

respectively) and
User_Alias es.

Each list item may be prefixed with zero or more
`!’

operators.
An odd number of
`!’

operators negate the value of
the item; an even number just cancel each other out.

A
user name

uid

group

gid

netgroup

nonunix_group

or
nonunix_gid

may be enclosed in double quotes to avoid the
need for escaping special characters.
Alternately, special characters
may be specified in escaped hex mode, e.g. x20 for space.
When
using double quotes, any prefix characters must be included inside
the quotes.

The actual
nonunix_group

and
nonunix_gid

syntax depends on
the underlying group provider plugin (see the
group_plugin

description below).
For instance, the QAS AD plugin supports the following formats:

  • Group in the same domain: "%:Group Name"

  • Group in any domain: "%:Group [email protected]"

  • Group SID: "%:S-1-2-34-5678901234-5678901234-5678901234-567"

Note that quotes around group names are optional.
Unquoted strings must use a backslash
(`’

)

to escape spaces and special characters.
See
Sx Other special characters and reserved words

for a list of
characters that need to be escaped.


Runas_List ::= Runas_Member |
Runas_Member ‘,’ Runas_List

Runas_Member ::= ‘!’* user name |
‘!’* #uid |
‘!’* %group |
‘!’* %#gid |
‘!’* %:nonunix_group |
‘!’* %:#nonunix_gid |
‘!’* +netgroup |
‘!’* Runas_Alias

A
Runas_List

is similar to a
User_List

except that instead
of
User_Alias es

it can contain
Runas_Alias es

Note that
user names and groups are matched as strings.
In other words, two
users (groups) with the same uid (gid) are considered to be distinct.
If you wish to match all user names with the same uid (e.g.
root and toor), you can use a uid instead (#0 in the example given).


Host_List ::= Host |
Host ‘,’ Host_List

Host ::= ‘!’* host name |
‘!’* ip_addr |
‘!’* network(/netmask)? |
‘!’* +netgroup |
‘!’* Host_Alias

A
Host_List

is made up of one or more host names, IP addresses,
network numbers, netgroups (prefixed with
`+’

)
and other aliases.
Again, the value of an item may be negated with the
`!’

operator.
If you do not specify a netmask along with the network number,
sudo

will query each of the local host’s network interfaces and,
if the network number corresponds to one of the hosts’s network
interfaces, the corresponding netmask will be used.
The netmask
may be specified either in standard IP address notation
(e.g. 255.255.255.0 or ffff:ffff:ffff:ffff::),
or CIDR notation (number of bits, e.g. 24 or 64).
A host name may include shell-style wildcards (see the
Sx Wildcards

section below),
but unless the
host name

command on your machine returns the fully
qualified host name, you’ll need to use the
fqdn

option for wildcards to be useful.
Note that
sudo

only inspects actual network interfaces; this means that IP address
127.0.0.1 (localhost) will never match.
Also, the host name
“localhost”

will only match if that is the actual host name, which is usually
only the case for non-networked systems.


Cmnd_List ::= Cmnd |
Cmnd ‘,’ Cmnd_List

command name ::= file name |
file name args |
file name ‘""’

Cmnd ::= ‘!’* command name |
‘!’* directory |
‘!’* "sudoedit" |
‘!’* Cmnd_Alias

A
Cmnd_List

is a list of one or more command names, directories, and other aliases.
A command name is a fully qualified file name which may include
shell-style wildcards (see the
Sx Wildcards

section below).
A simple file name allows the user to run the command with any
arguments he/she wishes.
However, you may also specify command line arguments (including
wildcards).
Alternately, you can specify

to indicate that the command
may only be run
without

command line arguments.
A directory is a
fully qualified path name ending in a
`/’

When you specify a directory in a
Cmnd_List

the user will be able to run any file within that directory
(but not in any sub-directories therein).

If a
Cmnd

has associated command line arguments, then the arguments
in the
Cmnd

must match exactly those given by the user on the command line
(or match the wildcards if there are any).
Note that the following characters must be escaped with a
`’

if they are used in command arguments:
`,’

,
`:’

,
`=’

,
`’

The special command
sudoedit

is used to permit a user to run
sudo

with the
-e

option (or as
sudoedit )

It may take command line arguments just as a normal command does.
 

Defaults

Certain configuration options may be changed from their default
values at run-time via one or more
Default_Entry

lines.
These may affect all users on any host, all users on a specific host, a
specific user, a specific command, or commands being run as a specific user.
Note that per-command entries may not include command line arguments.
If you need to specify arguments, define a
Cmnd_Alias

and reference
that instead.


Default_Type ::= ‘Defaults’ |
‘Defaults’ ‘@’ Host_List |
‘Defaults’ ‘:’ User_List |
‘Defaults’ ‘!’ Cmnd_List |
‘Defaults’ ‘>’ Runas_List

Default_Entry ::= Default_Type Parameter_List

Parameter_List ::= Parameter |
Parameter ‘,’ Parameter_List

Parameter ::= Parameter ‘=’ Value |
Parameter ‘+=’ Value |
Parameter ‘-=’ Value |
‘!’* Parameter

Parameters may be
flags

integer

values,
strings

or
lists

Flags are implicitly boolean and can be turned off via the
`!’

operator.
Some integer, string and list parameters may also be
used in a boolean context to disable them.
Values may be enclosed
in double quotes
()

when they contain multiple words.
Special characters may be escaped with a backslash
(`’

)

Lists have two additional assignment operators,
+=

and
-=

These operators are used to add to and delete from a list respectively.
It is not an error to use the
-=

operator to remove an element
that does not exist in a list.

Defaults entries are parsed in the following order: generic, host
and user Defaults first, then runas Defaults and finally command
defaults.

See
Sx SUDOERS OPTIONS

for a list of supported Defaults parameters.
 

User specification


User_Spec ::= User_List Host_List ‘=’ Cmnd_Spec_List
(‘:’ Host_List ‘=’ Cmnd_Spec_List)*

Cmnd_Spec_List ::= Cmnd_Spec |
Cmnd_Spec ‘,’ Cmnd_Spec_List

Cmnd_Spec ::= Runas_Spec? SELinux_Spec? Tag_Spec* Cmnd

Runas_Spec ::= ‘(‘ Runas_List? (‘:’ Runas_List)? ‘)’

SELinux_Spec ::= (‘ROLE=role’ | ‘TYPE=type’)

Tag_Spec ::= (‘NOPASSWD:’ | ‘PASSWD:’ | ‘NOEXEC:’ | ‘EXEC:’ |
‘SETENV:’ | ‘NOSETENV:’ | ‘LOG_INPUT:’ | ‘NOLOG_INPUT:’ |
‘LOG_OUTPUT:’ | ‘NOLOG_OUTPUT:’)

A
user specification

determines which commands a user may run
(and as what user) on specified hosts.
By default, commands are
run as
root

but this can be changed on a per-command basis.

The basic structure of a user specification is
“who where = (as_whom) what”

Let’s break that down into its constituent parts:
 

Runas_Spec

A
Runas_Spec

determines the user and/or the group that a command
may be run as.
A fully-specified
Runas_Spec

consists of two
Runas_List s

(as defined above) separated by a colon
(`:’

)

and enclosed in a set of parentheses.
The first
Runas_List

indicates
which users the command may be run as via
sudo ‘s

-u

option.
The second defines a list of groups that can be specified via
sudo ‘s

-g

option.
If both
Runas_List s

are specified, the command may be run with any combination of users
and groups listed in their respective
Runas_List s.

If only the first is specified, the command may be run as any user
in the list but no
-g

option
may be specified.
If the first
Runas_List

is empty but the
second is specified, the command may be run as the invoking user
with the group set to any listed in the
Runas_List

If both
Runas_List s

are empty, the command may only be run as the invoking user.
If no
Runas_Spec

is specified the command may be run as
root

and
no group may be specified.

A
Runas_Spec

sets the default for the commands that follow it.
What this means is that for the entry:


dgb boulder = (operator) /bin/ls, /bin/kill, /usr/bin/lprm

The user
dgb

may run
/bin/ls

/bin/kill

and
/usr/bin/lprm — but

only as
operator

E.g.,


$ sudo -u operator /bin/ls

It is also possible to override a
Runas_Spec

later on in an entry.
If we modify the entry like so:


dgb boulder = (operator) /bin/ls, (root) /bin/kill, /usr/bin/lprm

Then user
dgb

is now allowed to run
/bin/ls

as
operator

but
/bin/kill

and
/usr/bin/lprm

as
root

We can extend this to allow
dgb

to run
/bin/ls

with either
the user or group set to
operator


dgb boulder = (operator : operator) /bin/ls, (root) /bin/kill,
/usr/bin/lprm

Note that while the group portion of the
Runas_Spec

permits the
user to run as command with that group, it does not force the user
to do so.
If no group is specified on the command line, the command
will run with the group listed in the target user’s password database
entry.
The following would all be permitted by the sudoers entry above:


$ sudo -u operator /bin/ls
$ sudo -u operator -g operator /bin/ls
$ sudo -g operator /bin/ls

In the following example, user
tcm

may run commands that access
a modem device file with the dialer group.


tcm boulder = (:dialer) /usr/bin/tip, /usr/bin/cu,
/usr/local/bin/minicom

Note that in this example only the group will be set, the command
still runs as user
tcm

E.g.


$ sudo -g dialer /usr/bin/cu

Multiple users and groups may be present in a
Runas_Spec

in which case the user may select any combination of users and groups via the
-u

and
-g

options.
In this example:


alan ALL = (root, bin : operator, system) ALL

user
alan

may run any command as either user root or bin,
optionally setting the group to operator or system.
 

SELinux_Spec

On systems with SELinux support,
sudoers

entries may optionally have an SELinux role and/or type associated
with a command.
If a role or
type is specified with the command it will override any default values
specified in
sudoers

A role or type specified on the command line,
however, will supersede the values in
sudoers

 

Tag_Spec

A command may have zero or more tags associated with it.
There are
ten possible tag values:
NOPASSWD

PASSWD

NOEXEC

EXEC

SETENV

NOSETENV

LOG_INPUT

NOLOG_INPUT

LOG_OUTPUT

and
NOLOG_OUTPUT

Once a tag is set on a
Cmnd

subsequent
Cmnd s

in the
Cmnd_Spec_List

inherit the tag unless it is overridden by the opposite tag (in other words,
PASSWD

overrides
NOPASSWD

and
NOEXEC

overrides
EXEC )

NOPASSWD and PASSWD

By default,
sudo

requires that a user authenticate him or herself
before running a command.
This behavior can be modified via the
NOPASSWD

tag.
Like a
Runas_Spec

the
NOPASSWD

tag sets
a default for the commands that follow it in the
Cmnd_Spec_List

Conversely, the
PASSWD

tag can be used to reverse things.
For example:


ray rushmore = NOPASSWD: /bin/kill, /bin/ls, /usr/bin/lprm

would allow the user
ray

to run
/bin/kill

/bin/ls

and
/usr/bin/lprm

as
root

on the machine rushmore without authenticating himself.
If we only want
ray

to be able to
run
/bin/kill

without a password the entry would be:


ray rushmore = NOPASSWD: /bin/kill, PASSWD: /bin/ls, /usr/bin/lprm

Note, however, that the
PASSWD

tag has no effect on users who are in the group specified by the
exempt_group

option.

By default, if the
NOPASSWD

tag is applied to any of the entries for a user on the current host,
he or she will be able to run
sudo -l

without a password.
Additionally, a user may only run
sudo -v

without a password if the
NOPASSWD

tag is present for all a user’s entries that pertain to the current host.
This behavior may be overridden via the
verifypw

and
listpw

options.

NOEXEC and EXEC

If
sudo

has been compiled with
noexec

support and the underlying operating system supports it, the
NOEXEC

tag can be used to prevent a dynamically-linked executable from
running further commands itself.

In the following example, user
aaron

may run
/usr/bin/more

and
/usr/bin/vi

but shell escapes will be disabled.


aaron shanty = NOEXEC: /usr/bin/more, /usr/bin/vi

See the
Sx Preventing shell escapes

section below for more details on how
NOEXEC

works and whether or not it will work on your system.

SETENV and NOSETENV

These tags override the value of the
setenv

option on a per-command basis.
Note that if
SETENV

has been set for a command, the user may disable the
env_reset

option from the command line via the
-E

option.
Additionally, environment variables set on the command
line are not subject to the restrictions imposed by
env_check

env_delete

or
env_keep

As such, only trusted users should be allowed to set variables in this manner.
If the command matched is
ALL

the
SETENV

tag is implied for that command; this default may be overridden by use of the
NOSETENV

tag.

LOG_INPUT and NOLOG_INPUT

These tags override the value of the
log_input

option on a per-command basis.
For more information, see the description of
log_input

in the
Sx SUDOERS OPTIONS

section below.

LOG_OUTPUT and NOLOG_OUTPUT

These tags override the value of the
log_output

option on a per-command basis.
For more information, see the description of
log_output

in the
Sx SUDOERS OPTIONS

section below.
 

Wildcards

sudo

allows shell-style
wildcards

(aka meta or glob characters)
to be used in host names, path names and command line arguments in the
sudoers

file.
Wildcard matching is done via the
POSIX

glob(3)

and
fnmatch(3)

routines.
Note that these are
not

regular expressions.


*


Matches any set of zero or more characters.
?


Matches any single character.
[...]


Matches any character in the specified range.
[!...]


Matches any character
not

in the specified range.

x


For any character
`x’

evaluates to
`x’

This is used to escape special characters such as:
`*’

,
`?’

,
`['

,
and
`]‘


POSIX character classes may also be used if your system’s
glob(3)

and
fnmatch(3)

functions support them.
However, because the
`:’

character has special meaning in
sudoers

it must be
escaped.
For example:


/bin/ls [[:alpha:]]*

Would match any file name beginning with a letter.

Note that a forward slash
(`/’

)

will
not

be matched by
wildcards used in the path name.
This is to make a path like:


/usr/bin/*

match
/usr/bin/who

but not
/usr/bin/X11/xterm

When matching the command line arguments, however, a slash
does

get matched by wildcards since command line arguments may contain
arbitrary strings and not just path names.

Wildcards in command line arguments should be used with care.
Because command line arguments are matched as a single, concatenated
string, a wildcard such as
`?’

or
`*’

can match multiple words.
For example, while a sudoers entry like:


%operator ALL = /bin/cat /var/log/messages*

will allow command like:


$ sudo cat /var/log/messages.1

It will also allow:


$ sudo cat /var/log/messages /etc/shadow

which is probably not what was intended.
 

Exceptions to wildcard rules

The following exceptions apply to the above rules:



If the empty string

is the only command line argument in the
sudoers

entry it means that command is not allowed to be run with
any

arguments.

sudoedit

Command line arguments to the
sudoedit

built-in command should always be path names, so a forward slash
(`/’

)

will not be matched by a wildcard.


 

Including other files from within sudoers

It is possible to include other
sudoers

files from within the
sudoers

file currently being parsed using the
#include

and
#includedir

directives.

This can be used, for example, to keep a site-wide
sudoers

file in addition to a local, per-machine file.
For the sake of this example the site-wide
sudoers

will be
/etc/sudoers

and the per-machine one will be
/etc/sudoers.local

To include
/etc/sudoers.local

from within
/etc/sudoers

we would use the
following line in
/etc/sudoers


#include /etc/sudoers.local

When
sudo

reaches this line it will suspend processing of the current file
(/etc/sudoers

)

and switch to
/etc/sudoers.local

Upon reaching the end of
/etc/sudoers.local

the rest of
/etc/sudoers

will be processed.
Files that are included may themselves include other files.
A hard limit of 128 nested include files is enforced to prevent include
file loops.

If the path to the include file is not fully-qualified (does not
begin with a
`/’

,
it must be located in the same directory as the sudoers file it was
included from.
For example, if
/etc/sudoers

contains the line:


#include sudoers.local

the file that will be included is
/etc/sudoers.local

The file name may also include the
%h

escape, signifying the short form of the host name.
In other words, if the machine’s host name is
“xerxes”

then


#include /etc/sudoers.%h

will cause
sudo

to include the file
/etc/sudoers.xerxes

The
#includedir

directive can be used to create a
sudo.d

directory that the system package manager can drop
sudoers

rules
into as part of package installation.
For example, given:


#includedir /etc/sudoers.d

sudo

will read each file in
/etc/sudoers.d

skipping file names that end in
`~’

or contain a
`.’

character to avoid causing problems with package manager or editor
temporary/backup files.
Files are parsed in sorted lexical order.
That is,
/etc/sudoers.d/01_first

will be parsed before
/etc/sudoers.d/10_second

Be aware that because the sorting is lexical, not numeric,
/etc/sudoers.d/1_whoops

would be loaded
after

/etc/sudoers.d/10_second

Using a consistent number of leading zeroes in the file names can be used
to avoid such problems.

Note that unlike files included via
#include

visudo

will not edit the files in a
#includedir

directory unless one of them contains a syntax error.
It is still possible to run
visudo

with the
-f

flag to edit the files directly.
 

Other special characters and reserved words

The pound sign
(`#’

)

is used to indicate a comment (unless it is part of a #include
directive or unless it occurs in the context of a user name and is
followed by one or more digits, in which case it is treated as a
uid).
Both the comment character and any text after it, up to the end of
the line, are ignored.

The reserved word
ALL

is a built-in
alias

that always causes a match to succeed.
It can be used wherever one might otherwise use a
Cmnd_Alias

User_Alias

Runas_Alias

or
Host_Alias

You should not try to define your own
alias

called
ALL

as the built-in alias will be used in preference to your own.
Please note that using
ALL

can be dangerous since in a command context, it allows the user to run
any

command on the system.

An exclamation point
(`!’

)

can be used as a logical
not

operator in a list or
alias

as well as in front of a
Cmnd

This allows one to exclude certain values.
For the
`!’

operator to be effective, there must be something for it to exclude.
For example, to match all users except for root one would use:


ALL,!root

If the
ALL

is omitted, as in:


!root

it would explicitly deny root but not match any other users.
This is different from a true
“negation”

operator.

Note, however, that using a
`!’

in conjunction with the built-in
ALL

alias to allow a user to run
“all but a few”

commands rarely works as intended (see
Sx SECURITY NOTES

below).

Long lines can be continued with a backslash
(`’

)

as the last character on the line.

White space between elements in a list as well as special syntactic
characters in a
User Specification

Po `=’

,
`:’

,
`(‘

,
`)’

Pc is optional.

The following characters must be escaped with a backslash
(`’

)

when used as part of a word (e.g. a user name or host name):
`!’

,
`=’

,
`:’

,
`,’

,
`(‘

,
`)’

,
`’

 

SUDOERS OPTIONS

sudo ‘s

behavior can be modified by
Default_Entry

lines, as explained earlier.
A list of all supported Defaults parameters, grouped by type, are listed below.

Boolean Flags


always_set_home

If enabled,
sudo

will set the
HOME

environment variable to the home directory of the target user
(which is root unless the
-u

option is used).
This effectively means that the
-H

option is always implied.
Note that
HOME

is already set when the the
env_reset

option is enabled, so
always_set_home

is only effective for configurations where either
env_reset

is disabled or
HOME

is present in the
env_keep

list.
This flag is
off

by default.

authenticate

If set, users must authenticate themselves via a password (or other
means of authentication) before they may run commands.
This default may be overridden via the
PASSWD

and
NOPASSWD

tags.
This flag is
on

by default.

closefrom_override

If set, the user may use
sudo ‘s

-C

option which overrides the default starting point at which
sudo

begins closing open file descriptors.
This flag is
off

by default.

compress_io

If set, and
sudo

is configured to log a command’s input or output,
the I/O logs will be compressed using
zlib

This flag is
on

by default when
sudo

is compiled with
zlib

support.

env_editor

If set,
visudo

will use the value of the
EDITOR

or
VISUAL

environment variables before falling back on the default editor list.
Note that this may create a security hole as it allows the user to
run any arbitrary command as root without logging.
A safer alternative is to place a colon-separated list of editors
in the
editor

variable.
visudo

will then only use the
EDITOR

or
VISUAL

if they match a value specified in
editor

This flag is
on

by
default.

env_reset

If set,
sudo

will run the command in a minimal environment containing the
TERM

PATH

HOME

MAIL

SHELL

LOGNAME

USER

USERNAME

and
SUDO_*

variables.
Any
variables in the caller’s environment that match the
env_keep

and
env_check

lists are then added, followed by any variables present in the file
specified by the
env_file

option (if any).
The default contents of the
env_keep

and
env_check

lists are displayed when
sudo

is run by root with the
-V

option.
If the
secure_path

option is set, its value will be used for the
PATH

environment variable.
This flag is
on

by default.

fast_glob

Normally,
sudo

uses the
glob(3)

function to do shell-style globbing when matching path names.
However, since it accesses the file system,
glob(3)

can take a long time to complete for some patterns, especially
when the pattern references a network file system that is mounted
on demand (auto mounted).
The
fast_glob

option causes
sudo

to use the
fnmatch(3)

function, which does not access the file system to do its matching.
The disadvantage of
fast_glob

is that it is unable to match relative path names such as
./ls

or
../bin/ls

This has security implications when path names that include globbing
characters are used with the negation operator,
`!’

,
as such rules can be trivially bypassed.
As such, this option should not be used when
sudoers

contains rules that contain negated path names which include globbing
characters.
This flag is
off

by default.

fqdn

Set this flag if you want to put fully qualified host names in the
sudoers

file when the local host name (as returned by the
hostname

command) does not contain the domain name.
In other words, instead of myhost you would use myhost.mydomain.edu.
You may still use the short form if you wish (and even mix the two).
This option is only effective when the
“canonical”

host name, as returned by the
Fn getaddrinfo

or
Fn gethostbyname

function, is a fully-qualified domain name.
This is usually the case when the system is configured to use DNS
for host name resolution.

If the system is configured to use the
/etc/hosts

file in preference to DNS, the
“canonical”

host name may not be fully-qualified.
The order that sources are queried for hosts name resolution
is usually specified in the
/etc/nsswitch.conf

/etc/netsvc.conf

/etc/host.conf

or, in some cases,
/etc/resolv.conf

file.
In the
/etc/hosts

file, the first host name of the entry is considered to be the
“canonical”

name; subsequent names are aliases that are not used by
sudoers

For example, the following hosts file line for the machine
“xyzzy”

has the fully-qualified domain name as the
“canonical”

host name, and the short version as an alias.

192.168.1.1    xyzzy.sudo.ws xyzzy



If the machine’s hosts file entry is not formatted properly, the

fqdn

option will not be effective if it is queried before DNS.

Beware that when using DNS for host name resolution, turning on
fqdn

requires
sudoers

to make DNS lookups which renders
sudo

unusable if DNS stops working (for example if the machine is disconnected
from the network).
Also note that just like with the hosts file, you must use the
“canonical”

name as DNS knows it.
That is, you may not use a host alias
Po CNAME

entry
Pc due to performance issues and the fact that there is no way to get all

aliases from DNS.

This flag is
off

by default.

ignore_dot

If set,
sudo

will ignore "." or "" (both denoting current directory) in the
PATH

environment variable; the
PATH

itself is not modified.
This flag is
on

by default.

ignore_local_sudoers

If set via LDAP, parsing of
/etc/sudoers

will be skipped.
This is intended for Enterprises that wish to prevent the usage of local
sudoers files so that only LDAP is used.
This thwarts the efforts of rogue operators who would attempt to add roles to
/etc/sudoers

When this option is present,
/etc/sudoers

does not even need to exist.
Since this option tells
sudo

how to behave when no specific LDAP entries have been matched, this
sudoOption is only meaningful for the
cn=defaults

section.
This flag is
off

by default.

insults

If set,
sudo

will insult users when they enter an incorrect password.
This flag is
off

by default.

log_host

If set, the host name will be logged in the (non-syslog)
sudo

log file.
This flag is
off

by default.

log_input

If set,
sudo

will run the command in a
pseudo tty

and log all user input.
If the standard input is not connected to the user’s tty, due to
I/O redirection or because the command is part of a pipeline, that
input is also captured and stored in a separate log file.

Input is logged to the directory specified by the
iolog_dir

option
Po /var/log/sudo-io

by default
Pc using a unique session ID that is included in the normal

sudo

log line, prefixed with
TSID=

The
iolog_file

option may be used to control the format of the session ID.

Note that user input may contain sensitive information such as
passwords (even if they are not echoed to the screen), which will
be stored in the log file unencrypted.
In most cases, logging the command output via
log_output

is all that is required.

log_output

If set,
sudo

will run the command in a
pseudo tty

and log all output that is sent to the screen, similar to the
script(1)

command.
If the standard output or standard error is not connected to the
user’s tty, due to I/O redirection or because the command is part
of a pipeline, that output is also captured and stored in separate
log files.

Output is logged to the directory specified by the
iolog_dir

option
Po /var/log/sudo-io

by default
Pc using a unique session ID that is included in the normal

sudo

log line, prefixed with
TSID=

The
iolog_file

option may be used to control the format of the session ID.

Output logs may be viewed with the
sudoreplay(8)

utility, which can also be used to list or search the available logs.

log_year

If set, the four-digit year will be logged in the (non-syslog)
sudo

log file.
This flag is
off

by default.

long_otp_prompt

When validating with a One Time Password (OTP) scheme such as
S/Key

or
OPIE

a two-line prompt is used to make it easier
to cut and paste the challenge to a local window.
It’s not as pretty as the default but some people find it more convenient.
This flag is
off

by default.

mail_always

Send mail to the
mailto

user every time a users runs
sudo

This flag is
off

by default.

mail_badpass

Send mail to the
mailto

user if the user running
sudo

does not enter the correct password.
If the command the user is attempting to run is not permitted by
sudoers

and one of the
mail_always

mail_no_host

mail_no_perms

or
mail_no_user

flags are set, this flag will have no effect.
This flag is
off

by default.

mail_no_host

If set, mail will be sent to the
mailto

user if the invoking user exists in the
sudoers

file, but is not allowed to run commands on the current host.
This flag is
off

by default.

mail_no_perms

If set, mail will be sent to the
mailto

user if the invoking user is allowed to use
sudo

but the command they are trying is not listed in their
sudoers

file entry or is explicitly denied.
This flag is
off

by default.

mail_no_user

If set, mail will be sent to the
mailto

user if the invoking user is not in the
sudoers

file.
This flag is
on

by default.

noexec

If set, all commands run via
sudo

will behave as if the
NOEXEC

tag has been set, unless overridden by a
EXEC

tag.
See the description of
NOEXEC and EXEC

below as well as the
Sx Preventing shell escapes

section at the end of this manual.
This flag is
off

by default.

path_info

Normally,
sudo

will tell the user when a command could not be
found in their
PATH

environment variable.
Some sites may wish to disable this as it could be used to gather
information on the location of executables that the normal user does
not have access to.
The disadvantage is that if the executable is simply not in the user’s
PATH

sudo

will tell the user that they are not allowed to run it, which can be confusing.
This flag is
on

by default.

passprompt_override

The password prompt specified by
passprompt

will normally only be used if the password prompt provided by systems
such as PAM matches the string
“Password:”

If
passprompt_override

is set,
passprompt

will always be used.
This flag is
off

by default.

preserve_groups

By default,
sudo

will initialize the group vector to the list of groups the target user is in.
When
preserve_groups

is set, the user’s existing group vector is left unaltered.
The real and effective group IDs, however, are still set to match the
target user.
This flag is
off

by default.

pwfeedback

By default,
sudo

reads the password like most other Unix programs,
by turning off echo until the user hits the return (or enter) key.
Some users become confused by this as it appears to them that
sudo

has hung at this point.
When
pwfeedback

is set,
sudo

will provide visual feedback when the user presses a key.
Note that this does have a security impact as an onlooker may be able to
determine the length of the password being entered.
This flag is
off

by default.

requiretty

If set,
sudo

will only run when the user is logged in to a real tty.
When this flag is set,
sudo

can only be run from a login session and not via other means such as
cron(8)

or cgi-bin scripts.
This flag is
off

by default.

root_sudo

If set, root is allowed to run
sudo

too.
Disabling this prevents users from
“chaining”

sudo

commands to get a root shell by doing something like
sudo sudo /bin/sh

Note, however, that turning off
root_sudo

will also prevent root from running
sudoedit

Disabling
root_sudo

provides no real additional security; it exists purely for historical reasons.
This flag is
on

by default.

rootpw

If set,
sudo

will prompt for the root password instead of the password of the invoking user.
This flag is
off

by default.

runaspw

If set,
sudo

will prompt for the password of the user defined by the
runas_default

option (defaults to
root

instead of the password of the invoking user.
This flag is
off

by default.

set_home

If enabled and
sudo

is invoked with the
-s

option the
HOME

environment variable will be set to the home directory of the target
user (which is root unless the
-u

option is used).
This effectively makes the
-s

option imply
-H

Note that
HOME

is already set when the the
env_reset

option is enabled, so
set_home

is only effective for configurations where either
env_reset

is disabled
or
HOME

is present in the
env_keep

list.
This flag is
off

by default.

set_logname

Normally,
sudo

will set the
LOGNAME

USER

and
USERNAME

environment variables to the name of the target user (usually root unless the
-u

option is given).
However, since some programs (including the RCS revision control system) use
LOGNAME

to determine the real identity of the user, it may be desirable to
change this behavior.
This can be done by negating the set_logname option.
Note that if the
env_reset

option has not been disabled, entries in the
env_keep

list will override the value of
set_logname

This flag is
on

by default.

set_utmp

When enabled,
sudo

will create an entry in the utmp (or utmpx) file when a pseudo-tty
is allocated.
A pseudo-tty is allocated by
sudo

when the
log_input

log_output

or
use_pty

flags are enabled.
By default, the new entry will be a copy of the user’s existing utmp
entry (if any), with the tty, time, type and pid fields updated.
This flag is
on

by default.

setenv

Allow the user to disable the
env_reset

option from the command line via the
-E

option.
Additionally, environment variables set via the command line are
not subject to the restrictions imposed by
env_check

env_delete

or
env_keep

As such, only trusted users should be allowed to set variables in this manner.
This flag is
off

by default.

shell_noargs

If set and
sudo

is invoked with no arguments it acts as if the
-s

option had been given.
That is, it runs a shell as root (the shell is determined by the
SHELL

environment variable if it is set, falling back on the shell listed
in the invoking user’s /etc/passwd entry if not).
This flag is
off

by default.

stay_setuid

Normally, when
sudo

executes a command the real and effective UIDs are set to the target
user (root by default).
This option changes that behavior such that the real UID is left
as the invoking user’s UID.
In other words, this makes
sudo

act as a setuid wrapper.
This can be useful on systems that disable some potentially
dangerous functionality when a program is run setuid.
This option is only effective on systems that support either the
setreuid(2)

or
setresuid(2)

system call.
This flag is
off

by default.

targetpw

If set,
sudo

will prompt for the password of the user specified
by the
-u

option (defaults to
root

instead of the password of the invoking user.
In addition, the time stamp file name will include the target user’s name.
Note that this flag precludes the use of a uid not listed in the passwd
database as an argument to the
-u

option.
This flag is
off

by default.

tty_tickets

If set, users must authenticate on a per-tty basis.
With this flag enabled,
sudo

will use a file named for the tty the user is
logged in on in the user’s time stamp directory.
If disabled, the time stamp of the directory is used instead.
This flag is
on

by default.

umask_override

If set,
sudo

will set the umask as specified by
sudoers

without modification.
This makes it possible to specify a more permissive umask in
sudoers

than the user’s own umask and matches historical behavior.
If
umask_override

is not set,
sudo

will set the umask to be the union of the user’s umask and what is specified in
sudoers

This flag is
off

by default.
If set,
sudo

will run the command in a pseudo-pty even if no I/O logging is being gone.
A malicious program run under
sudo

could conceivably fork a background process that retains to the user’s
terminal device after the main program has finished executing.
Use of this option will make that impossible.
This flag is
off

by default.

utmp_runas

If set,
sudo

will store the name of the runas user when updating the utmp (or utmpx) file.
By default,
sudo

stores the name of the invoking user.
This flag is
off

by default.

visiblepw

By default,
sudo

will refuse to run if the user must enter a password but it is not
possible to disable echo on the terminal.
If the
visiblepw

flag is set,
sudo

will prompt for a password even when it would be visible on the screen.
This makes it possible to run things like
ssh somehost sudo ls

since by default,
ssh(1)

does
not allocate a tty when running a command.
This flag is
off

by default.


Integers


closefrom

Before it executes a command,
sudo

will close all open file descriptors other than standard input,
standard output and standard error (ie: file descriptors 0-2).
The
closefrom

option can be used to specify a different file descriptor at which
to start closing.
The default is
3

passwd_tries

The number of tries a user gets to enter his/her password before
sudo

logs the failure and exits.
The default is
3


Integers that can be used in a boolean context


loglinelen

Number of characters per line for the file log.
This value is used to decide when to wrap lines for nicer log files.
This has no effect on the syslog log file, only the file log.
The default is
80

(use 0 or negate the option to disable word wrap).

passwd_timeout

Number of minutes before the
sudo

password prompt times out, or
0

for no timeout.
The timeout may include a fractional component
if minute granularity is insufficient, for example
2.5

The
default is
5

timestamp_timeout

Number of minutes that can elapse before
sudo

will ask for a passwd again.
The timeout may include a fractional component if
minute granularity is insufficient, for example
2.5

The default is
5

Set this to
0

to always prompt for a password.
If set to a value less than
0

the user’s time stamp will never expire.
This can be used to allow users to create or delete their own time stamps via
sudo -v

and
sudo -k

respectively.

umask

Umask to use when running the command.
Negate this option or set it to 0777 to preserve the user’s umask.
The actual umask that is used will be the union of the user’s umask
and the value of the
umask

option, which defaults to
0022

This guarantees
that
sudo

never lowers the umask when running a command.
Note: on systems that use PAM, the default PAM configuration may specify
its own umask which will override the value set in
sudoers


Strings


badpass_message

Message that is displayed if a user enters an incorrect password.
The default is
Sorry, try again.

unless insults are enabled.

editor

A colon
(`:’

)

separated list of editors allowed to be used with
visudo

visudo

will choose the editor that matches the user’s
EDITOR

environment variable if possible, or the first editor in the
list that exists and is executable.
The default is
/usr/local/bin/vi

iolog_dir

The top-level directory to use when constructing the path name for
the input/output log directory.
Only used if the
log_input

or
log_output

options are enabled or when the
LOG_INPUT

or
LOG_OUTPUT

tags are present for a command.
The session sequence number, if any, is stored in the directory.
The default is
/var/log/sudo-io

The following percent
(`%’

)

escape sequences are supported:


%{seq}


expanded to a monotonically increasing base-36 sequence number, such as 0100A5,
where every two digits are used to form a new directory, e.g.
01/00/A5

%{user}


expanded to the invoking user’s login name
%{group}


expanded to the name of the invoking user’s real group ID
%{runas_user}


expanded to the login name of the user the command will
be run as (e.g. root)
%{runas_group}


expanded to the group name of the user the command will
be run as (e.g. wheel)
%{hostname}


expanded to the local host name without the domain name
%{command}


expanded to the base name of the command being run

In addition, any escape sequences supported by the system’s
strftime(3)

function will be expanded.

To include a literal
`%’

character, the string
`%%’

should be used.

iolog_file

The path name, relative to
iolog_dir

in which to store input/output logs when the
log_input

or
log_output

options are enabled or when the
LOG_INPUT

or
LOG_OUTPUT

tags are present for a command.
Note that
iolog_file

may contain directory components.
The default is
%{seq}

See the
iolog_dir

option above for a list of supported percent
(`%’

)

escape sequences.

In addition to the escape sequences, path names that end in six or
more
X s

will have the
X s

replaced with a unique combination of digits and letters, similar to the
mktemp(3)

function.

mailsub

Subject of the mail sent to the
mailto

user.
The escape
%h

will expand to the host name of the machine.
Default is
*** SECURITY information for %h ***

noexec_file

This option is no longer supported.
The path to the noexec file should now be set in the
/etc/sudo.conf

file.

passprompt

The default prompt to use when asking for a password; can be overridden via the
-p

option or the
SUDO_PROMPT

environment variable.
The following percent
(`%’

)

escape sequences are supported:


%H


expanded to the local host name including the domain name
(only if the machine’s host name is fully qualified or the
fqdn

option is set)

%h


expanded to the local host name without the domain name
%p


expanded to the user whose password is being asked for (respects the
rootpw

targetpw

and
runaspw

flags in
sudoers

%U


expanded to the login name of the user the command will
be run as (defaults to root)
%u


expanded to the invoking user’s login name
%%


two consecutive
%

characters are collapsed into a single
%

character


The default value is
[sudo] password for %p:

The default SELinux role to use when constructing a new security
context to run the command.
The default role may be overridden on a per-command basis in
sudoers

or via command line options.
This option is only available when
sudo

is built with SELinux support.

runas_default

The default user to run commands as if the
-u

option is not specified on the command line.
This defaults to
root

syslog_badpri

Syslog priority to use when user authenticates unsuccessfully.
Defaults to
alert

The following syslog priorities are supported:
alert

crit

debug

emerg

err

info

notice

and
warning

syslog_goodpri

Syslog priority to use when user authenticates successfully.
Defaults to
notice

See
Sx syslog_badpri

for the list of supported syslog priorities.

sudoers_locale

Locale to use when parsing the sudoers file, logging commands, and
sending email.
Note that changing the locale may affect how sudoers is interpreted.
Defaults to
C

timestampdir

The directory in which
sudo

stores its time stamp files.
The default is
/var/db/sudo

timestampowner

The owner of the time stamp directory and the time stamps stored therein.
The default is
root

type

The default SELinux type to use when constructing a new security
context to run the command.
The default type may be overridden on a per-command basis in
sudoers

or via command line options.
This option is only available when
sudo

is built with SELinux support.


Strings that can be used in a boolean context


env_file

The
env_file

option specifies the fully qualified path to a file containing variables
to be set in the environment of the program being run.
Entries in this file should either be of the form
VARIABLE=value

or
export VARIABLE=value

The value may optionally be surrounded by single or double quotes.
Variables in this file are subject to other
sudo

environment settings such as
env_keep

and
env_check

exempt_group

Users in this group are exempt from password and PATH requirements.
The group name specified should not include a
%

prefix.
This is not set by default.

group_plugin

A string containing a
sudoers

group plugin with optional arguments.
This can be used to implement support for the
nonunix_group

syntax described earlier.
The string should consist of the plugin
path, either fully-qualified or relative to the
/usr/libexec

directory, followed by any configuration arguments the plugin requires.
These arguments (if any) will be passed to the plugin’s initialization function.
If arguments are present, the string must be enclosed in double quotes
()

For example, given
/etc/sudo-group

a group file in Unix group format, the sample group plugin can be used:


Defaults group_plugin="sample_group.so /etc/sudo-group"

For more information see
sudo_plugin5.

lecture

This option controls when a short lecture will be printed along with
the password prompt.
It has the following possible values:

always

Always lecture the user.
never

Never lecture the user.
once

Only lecture the user the first time they run
sudo


If no value is specified, a value of
once

is implied.
Negating the option results in a value of
never

being used.
The default value is
once

lecture_file

Path to a file containing an alternate
sudo

lecture that will be used in place of the standard lecture if the named
file exists.
By default,
sudo

uses a built-in lecture.

listpw

This option controls when a password will be required when a user runs
sudo

with the
-l

option.
It has the following possible values:


all

All the user’s
sudoers

entries for the current host must have
the
NOPASSWD

flag set to avoid entering a password.

always

The user must always enter a password to use the
-l

option.

any

At least one of the user’s
sudoers

entries for the current host
must have the
NOPASSWD

flag set to avoid entering a password.

never

The user need never enter a password to use the
-l

option.


If no value is specified, a value of
any

is implied.
Negating the option results in a value of
never

being used.
The default value is
any

logfile

Path to the
sudo

log file (not the syslog log file).
Setting a path turns on logging to a file;
negating this option turns it off.
By default,
sudo

logs via syslog.

mailerflags

Flags to use when invoking mailer. Defaults to
-t

mailerpath

Path to mail program used to send warning mail.
Defaults to the path to sendmail found at configure time.
mailfrom

Address to use for the
“from”

address when sending warning and error mail.
The address should be enclosed in double quotes
()

to protect against
sudo

interpreting the
@

sign.
Defaults to the name of the user running
sudo

mailto

Address to send warning and error mail to.
The address should be enclosed in double quotes
()

to protect against
sudo

interpreting the
@

sign.
Defaults to
root

secure_path

Path used for every command run from
sudo

If you don’t trust the
people running
sudo

to have a sane
PATH

environment variable you may want to use this.
Another use is if you want to have the
“root path”

be separate from the
“user path”

Users in the group specified by the
exempt_group

option are not affected by
secure_path

This option is not set by default.

syslog

Syslog facility if syslog is being used for logging (negate to
disable syslog logging).
Defaults to
authpriv

The following syslog facilities are supported:
authpriv

(if your
OS supports it),
auth

daemon

user

local0

local1

local2

local3

local4

local5

local6

and
local7

verifypw

This option controls when a password will be required when a user runs
sudo

with the
-v

option.
It has the following possible values:


all

All the user’s
sudoers

entries for the current host must have the
NOPASSWD

flag set to avoid entering a password.

always

The user must always enter a password to use the
-v

option.

any

At least one of the user’s
sudoers

entries for the current host must have the
NOPASSWD

flag set to avoid entering a password.

never

The user need never enter a password to use the
-v

option.


If no value is specified, a value of
all

is implied.
Negating the option results in a value of
never

being used.
The default value is
all


Lists that can be used in a boolean context


env_check

Environment variables to be removed from the user’s environment if
the variable’s value contains
`%’

or
`/’

characters.
This can be used to guard against printf-style format vulnerabilities
in poorly-written programs.
The argument may be a double-quoted, space-separated list or a
single value without double-quotes.
The list can be replaced, added to, deleted from, or disabled by using
the
=

+=

-=

and
!

operators respectively.
Regardless of whether the
env_reset

option is enabled or disabled, variables specified by
env_check

will be preserved in the environment if they pass the aforementioned check.
The default list of environment variables to check is displayed when
sudo

is run by root with
the
-V

option.

env_delete

Environment variables to be removed from the user’s environment when the
env_reset

option is not in effect.
The argument may be a double-quoted, space-separated list or a
single value without double-quotes.
The list can be replaced, added to, deleted from, or disabled by using the
=

+=

-=

and
!

operators respectively.
The default list of environment variables to remove is displayed when
sudo

is run by root with the
-V

option.
Note that many operating systems will remove potentially dangerous
variables from the environment of any setuid process (such as
sudo )

env_keep

Environment variables to be preserved in the user’s environment when the
env_reset

option is in effect.
This allows fine-grained control over the environment
sudo -spawned

processes will receive.
The argument may be a double-quoted, space-separated list or a
single value without double-quotes.
The list can be replaced, added to, deleted from, or disabled by using the
=

+=

-=

and
!

operators respectively.
The default list of variables to keep
is displayed when
sudo

is run by root with the
-V

option.


 

LOG FORMAT

sudoers

can log events using either
syslog(3)

or a simple log file.
In each case the log format is almost identical.
 

Accepted command log entries

Commands that sudo runs are logged using the following format (split
into multiple lines for readability):


date hostname progname: username : TTY=ttyname ; PWD=cwd ;
USER=runasuser ; GROUP=runasgroup ; TSID=logid ;
ENV=env_vars COMMAND=command

Where the fields are as follows:


date

The date the command was run.
Typically, this is in the format
“MMM, DD, HH:MM:SS”

If logging via
syslog(3),

the actual date format is controlled by the syslog daemon.
If logging to a file and the
log_year

option is enabled,
the date will also include the year.

hostname

The name of the host
sudo

was run on.
This field is only present when logging via
syslog(3).

progname

The name of the program, usually
sudo

or
sudoedit

This field is only present when logging via
syslog(3).

username

The login name of the user who ran
sudo

ttyname

The short name of the terminal (e.g.
“console”

“tty01”

or
“pts/0”

sudo

was run on, or
“unknown”

if there was no terminal present.

cwd

The current working directory that
sudo

was run in.

runasuser

The user the command was run as.
runasgroup

The group the command was run as if one was specified on the command line.
logid

An I/O log identifier that can be used to replay the command’s output.
This is only present when the
log_input

or
log_output

option is enabled.

env_vars

A list of environment variables specified on the command line,
if specified.
command

The actual command that was executed.

Messages are logged using the locale specified by
sudoers_locale

which defaults to the
C

locale.
 

Denied command log entries

If the user is not allowed to run the command, the reason for the denial
will follow the user name.
Possible reasons include:


user NOT in sudoers

The user is not listed in the
sudoers

file.

user NOT authorized on host

The user is listed in the
sudoers

file but is not allowed to run commands on the host.

command not allowed

The user is listed in the
sudoers

file for the host but they are not allowed to run the specified command.

3 incorrect password attempts

The user failed to enter their password after 3 tries.
The actual number of tries will vary based on the number of
failed attempts and the value of the
passwd_tries

option.

a password is required

sudo ‘s

-n

option was specified but a password was required.

sorry, you are not allowed to set the following environment variables

The user specified environment variables on the command line that
were not allowed by
sudoers


 

Error log entries

If an error occurs,
sudoers

will log a message and, in most cases, send a message to the
administrator via email.
Possible errors include:


parse error in /etc/sudoers near line N

sudoers

encountered an error when parsing the specified file.
In some cases, the actual error may be one line above or below the
line number listed, depending on the type of error.

problem with defaults entries

The
sudoers

file contains one or more unknown Defaults settings.
This does not prevent
sudo

from running, but the
sudoers

file should be checked using
visudo

timestamp owner (username): such user


The time stamp directory owner, as specified by the
timestampowner

setting, could not be found in the password database.

unable to open/read /etc/sudoers

The
sudoers

file could not be opened for reading.
This can happen when the
sudoers

file is located on a remote file system that maps user ID 0 to
a different value.
Normally,
sudoers

tries to open
sudoers

using group permissions to avoid this problem.
Consider changing the ownership of
/etc/sudoers

by adding an option like
“sudoers_uid=N”

(where
`N’

is the user ID that owns the
sudoers

file) to the
sudoers

plugin line in the
/etc/sudo.conf

file.

unable to stat /etc/sudoers

The
/etc/sudoers

file is missing.

/etc/sudoers is not a regular file

The
/etc/sudoers

file exists but is not a regular file or symbolic link.

/etc/sudoers is owned by uid N, should be 0

The
sudoers

file has the wrong owner.
If you wish to change the
sudoers

file owner, please add
“sudoers_uid=N”

(where
`N’

is the user ID that owns the
sudoers

file) to the
sudoers

plugin line in the
/etc/sudo.conf

file.

/etc/sudoers is world writable

The permissions on the
sudoers

file allow all users to write to it.
The
sudoers

file must not be world-writable, the default file mode
is 0440 (readable by owner and group, writable by none).
The default mode may be changed via the
“sudoers_mode”

option to the
sudoers

plugin line in the
/etc/sudo.conf

file.

/etc/sudoers is owned by gid N, should be 1

The
sudoers

file has the wrong group ownership.
If you wish to change the
sudoers

file group ownership, please add
“sudoers_gid=N”

(where
`N’

is the group ID that owns the
sudoers

file) to the
sudoers

plugin line in the
/etc/sudo.conf

file.

unable to open /var/db/sudo/username/ttyname

sudoers

was unable to read or create the user’s time stamp file.

unable to write to /var/db/sudo/username/ttyname

sudoers

was unable to write to the user’s time stamp file.

unable to mkdir to /var/db/sudo/username

sudoers

was unable to create the user’s time stamp directory.


 

Notes on logging via syslog

By default,
sudoers

logs messages via
syslog(3).

The
date

hostname

and
progname

fields are added by the syslog daemon, not
sudoers

itself.
As such, they may vary in format on different systems.

On most systems,
syslog(3)

has a relatively small log buffer.
To prevent the command line arguments from being truncated,
sudoers

will split up log messages that are larger than 960 characters
(not including the date, hostname, and the string
“sudo )”

When a message is split, additional parts will include the string
“(command continued)

after the user name and before the continued command line arguments.
 

Notes on logging to a file

If the
logfile

option is set,
sudoers

will log to a local file, such as
/var/log/sudo

When logging to a file,
sudoers

uses a format similar to
syslog(3),

with a few important differences:

  1. The
    progname

    and
    hostname

    fields are not present.

  2. If the
    log_year

    option is enabled,
    the date will also include the year.

  3. Lines that are longer than
    loglinelen

    characters (80 by default) are word-wrapped and continued on the
    next line with a four character indent.
    This makes entries easier to read for a human being, but makes it
    more difficult to use
    grep(1)

    on the log files.
    If the
    loglinelen

    option is set to 0 (or negated with a
    `!’

    ) ,
    word wrap will be disabled.

 

SUDO.CONF

The
/etc/sudo.conf

file determines which plugins the
sudo

front end will load.
If no
/etc/sudo.conf

file
is present, or it contains no
Plugin

lines,
sudo

will use the
sudoers

security policy and I/O logging, which corresponds to the following
/etc/sudo.conf

file.


#
# Default /etc/sudo.conf file
#
# Format:
# Plugin plugin_name plugin_path plugin_options …
# Path askpass /path/to/askpass
# Path noexec /path/to/sudo_noexec.so
# Debug sudo /var/log/sudo_debug [email protected]
# Set disable_coredump true
#
# The plugin_path is relative to /usr/libexec unless
# fully qualified.
# The plugin_name corresponds to a global symbol in the plugin
# that contains the plugin interface structure.
# The plugin_options are optional.
#
Plugin policy_plugin sudoers.so
Plugin io_plugin sudoers.so

 

Plugin options

Starting with
sudo

1.8.5, it is possible to pass options to the
sudoers

plugin.
Options may be listed after the path to the plugin (i.e. after
sudoers.so )

multiple options should be space-separated.
For example:


Plugin sudoers_policy sudoers.so sudoers_file=/etc/sudoers sudoers_uid=0 sudoers_gid=0 sudoers_mode=0440

The following plugin options are supported:


sudoers_file=pathname

The
sudoers_file

option can be used to override the default path
to the
sudoers

file.

sudoers_uid=uid

The
sudoers_uid

option can be used to override the default owner of the sudoers file.
It should be specified as a numeric user ID.

sudoers_gid=gid

The
sudoers_gid

option can be used to override the default group of the sudoers file.
It should be specified as a numeric group ID.

sudoers_mode=mode

The
sudoers_mode

option can be used to override the default file mode for the sudoers file.
It should be specified as an octal value.


 

Debug flags

Versions 1.8.4 and higher of the
sudoers

plugin supports a debugging framework that can help track down what the
plugin is doing internally if there is a problem.
This can be configured in the
/etc/sudo.conf

file as described in
sudo(8).

The
sudoers

plugin uses the same debug flag format as the
sudo

front-end:
subsystem @ priority

The priorities used by
sudoers

in order of decreasing severity,
are:
crit

err

warn

notice

diag

info

trace

and
debug

Each priority, when specified, also includes all priorities higher than it.
For example, a priority of
notice

would include debug messages logged at
notice

and higher.

The following subsystems are used by
sudoers


alias


User_Alias

Runas_Alias

Host_Alias

and
Cmnd_Alias

processing

all


matches every subsystem
audit


BSM and Linux audit code
auth


user authentication
defaults


sudoers

Defaults

settings

env


environment handling
ldap


LDAP-based sudoers
logging


logging support
match


matching of users, groups, hosts and netgroups in
sudoers

netif


network interface handling
nss


network service switch handling in
sudoers

parser


sudoers

file parsing

perms


permission setting
plugin


The equivalent of
main

for the plugin.

pty


pseudo-tty related code
rbtree


redblack tree internals
util


utility functions

 

FILES


/etc/sudo.conf



Sudo front end configuration
/etc/sudoers



List of who can run what
/etc/group



Local groups file
/etc/netgroup



List of network groups
/var/log/sudo-io



I/O log files
/var/db/sudo



Directory containing time stamps for the
sudoers

security policy

/etc/environment



Initial environment for
-i

mode on AIX and Linux systems


 

EXAMPLES

Below are example
sudoers

entries.
Admittedly, some of these are a bit contrived.
First, we allow a few environment variables to pass and then define our
aliases


# Run X applications through sudo; HOME is used to find the
# .Xauthority file. Note that other programs use HOME to find
# configuration files and this may lead to privilege escalation!
Defaults env_keep += "DISPLAY HOME"

# User alias specification
User_Alias FULLTIMERS = millert, mikef, dowdy
User_Alias PARTTIMERS = bostley, jwfox, crawl
User_Alias WEBMASTERS = will, wendy, wim

# Runas alias specification
Runas_Alias OP = root, operator
Runas_Alias DB = oracle, sybase
Runas_Alias ADMINGRP = adm, oper

# Host alias specification
Host_Alias SPARC = bigtime, eclipse, moet, anchor :
SGI = grolsch, dandelion, black :
ALPHA = widget, thalamus, foobar :
HPPA = boa, nag, python
Host_Alias CUNETS = 128.138.0.0/255.255.0.0
Host_Alias CSNETS = 128.138.243.0, 128.138.204.0/24, 128.138.242.0
Host_Alias SERVERS = master, mail, www, ns
Host_Alias CDROM = orion, perseus, hercules

# Cmnd alias specification
Cmnd_Alias DUMPS = /usr/bin/mt, /usr/sbin/dump, /usr/sbin/rdump,
/usr/sbin/restore, /usr/sbin/rrestore
Cmnd_Alias KILL = /usr/bin/kill
Cmnd_Alias PRINTING = /usr/sbin/lpc, /usr/bin/lprm
Cmnd_Alias SHUTDOWN = /usr/sbin/shutdown
Cmnd_Alias HALT = /usr/sbin/halt
Cmnd_Alias REBOOT = /usr/sbin/reboot
Cmnd_Alias SHELLS = /usr/bin/sh, /usr/bin/csh, /usr/bin/ksh,
/usr/local/bin/tcsh, /usr/bin/rsh,
/usr/local/bin/zsh
Cmnd_Alias SU = /usr/bin/su
Cmnd_Alias PAGERS = /usr/bin/more, /usr/bin/pg, /usr/bin/less

Here we override some of the compiled in default values.
We want
sudo

to log via
syslog(3)

using the
auth

facility in all cases.
We don’t want to subject the full time staff to the
sudo

lecture, user
millert

need not give a password, and we don’t want to reset the
LOGNAME

USER

or
USERNAME

environment variables when running commands as root.
Additionally, on the machines in the
SERVERS

Host_Alias

we keep an additional local log file and make sure we log the year
in each log line since the log entries will be kept around for several years.
Lastly, we disable shell escapes for the commands in the PAGERS
Cmnd_Alias

Po /usr/bin/more

/usr/bin/pg

and
/usr/bin/less

Pc .


# Override built-in defaults
Defaults syslog=auth
Defaults>root !set_logname
Defaults:FULLTIMERS !lecture
Defaults:millert !authenticate
[email protected] log_year, logfile=/var/log/sudo.log
Defaults!PAGERS noexec

The
User specification

is the part that actually determines who may run what.


root ALL = (ALL) ALL
%wheel ALL = (ALL) ALL

We let
root

and any user in group
wheel

run any command on any host as any user.


FULLTIMERS ALL = NOPASSWD: ALL

Full time sysadmins
Po millert

mikef

and
dowdy

Pc may run any command on any host without authenticating themselves.


PARTTIMERS ALL = ALL

Part time sysadmins
bostley

jwfox

and
crawl

may run any command on any host but they must authenticate themselves
first (since the entry lacks the
NOPASSWD

tag).


jack CSNETS = ALL

The user
jack

may run any command on the machines in the
CSNETS

alias (the networks
128.138.243.0

128.138.204.0

and
128.138.242.0 )

Of those networks, only
128.138.204.0

has an explicit netmask (in CIDR notation) indicating it is a class C network.
For the other networks in
CSNETS

the local machine’s netmask will be used during matching.


lisa CUNETS = ALL

The user
lisa

may run any command on any host in the
CUNETS

alias (the class B network
128.138.0.0 )


operator ALL = DUMPS, KILL, SHUTDOWN, HALT, REBOOT, PRINTING,
sudoedit /etc/printcap, /usr/oper/bin/

The
operator

user may run commands limited to simple maintenance.
Here, those are commands related to backups, killing processes, the
printing system, shutting down the system, and any commands in the
directory
/usr/oper/bin/


joe ALL = /usr/bin/su operator

The user
joe

may only
su(1)

to operator.


pete HPPA = /usr/bin/passwd [A-Za-z]*, !/usr/bin/passwd root

%opers ALL = (: ADMINGRP) /usr/sbin/

Users in the
opers

group may run commands in
/usr/sbin/

as themselves
with any group in the
ADMINGRP

Runas_Alias

(the
adm

and
oper

groups).

The user
pete

is allowed to change anyone’s password except for
root on the
HPPA

machines.
Note that this assumes
passwd(1)

does not take multiple user names on the command line.


bob SPARC = (OP) ALL : SGI = (OP) ALL

The user
bob

may run anything on the
SPARC

and
SGI

machines as any user listed in the
OP

Runas_Alias

Po root

and
operator

Pc

jim +biglab = ALL

The user
jim

may run any command on machines in the
biglab

netgroup.
sudo

knows that
“biglab”

is a netgroup due to the
`+’

prefix.


+secretaries ALL = PRINTING, /usr/bin/adduser, /usr/bin/rmuser

Users in the
secretaries

netgroup need to help manage the printers as well as add and remove users,
so they are allowed to run those commands on all machines.


fred ALL = (DB) NOPASSWD: ALL

The user
fred

can run commands as any user in the
DB

Runas_Alias

Po oracle

or
sybase

Pc without giving a password.


john ALPHA = /usr/bin/su [!-]*, !/usr/bin/su *root*

On the
ALPHA

machines, user
john

may su to anyone except root but he is not allowed to specify any options
to the
su(1)

command.


jen ALL, !SERVERS = ALL

The user
jen

may run any command on any machine except for those in the
SERVERS

Host_Alias

(master, mail, www and ns).


jill SERVERS = /usr/bin/, !SU, !SHELLS

For any machine in the
SERVERS

Host_Alias

jill

may run
any commands in the directory
/usr/bin/

except for those commands
belonging to the
SU

and
SHELLS

Cmnd_Aliases


steve CSNETS = (operator) /usr/local/op_commands/

The user
steve

may run any command in the directory /usr/local/op_commands/
but only as user operator.


matt valkyrie = KILL

On his personal workstation, valkyrie,
matt

needs to be able to kill hung processes.


WEBMASTERS www = (www) ALL, (root) /usr/bin/su www

On the host www, any user in the
WEBMASTERS

User_Alias

(will, wendy, and wim), may run any command as user www (which owns the
web pages) or simply
su(1)

to www.


ALL CDROM = NOPASSWD: /sbin/umount /CDROM,
/sbin/mount -o nosuid,nodev /dev/cd0a /CDROM

Any user may mount or unmount a CD-ROM on the machines in the CDROM
Host_Alias

(orion, perseus, hercules) without entering a password.
This is a bit tedious for users to type, so it is a prime candidate
for encapsulating in a shell script.
 

SECURITY NOTES

 

Limitations of the So ! Sc operator

It is generally not effective to
“subtract”

commands from
ALL

using the
`!’

operator.
A user can trivially circumvent this by copying the desired command
to a different name and then executing that.
For example:


bill ALL = ALL, !SU, !SHELLS

Doesn’t really prevent
bill

from running the commands listed in
SU

or
SHELLS

since he can simply copy those commands to a different name, or use
a shell escape from an editor or other program.
Therefore, these kind of restrictions should be considered
advisory at best (and reinforced by policy).

In general, if a user has sudo
ALL

there is nothing to prevent them from creating their own program that gives
them a root shell (or making their own copy of a shell) regardless of any
`!’

elements in the user specification.
 

Security implications of fast_glob

If the
fast_glob

option is in use, it is not possible to reliably negate commands where the
path name includes globbing (aka wildcard) characters.
This is because the C library’s
fnmatch(3)

function cannot resolve relative paths.
While this is typically only an inconvenience for rules that grant privileges,
it can result in a security issue for rules that subtract or revoke privileges.

For example, given the following
sudoers

entry:


john ALL = /usr/bin/passwd [a-zA-Z0-9]*, /usr/bin/chsh [a-zA-Z0-9]*,
/usr/bin/chfn [a-zA-Z0-9]*, !/usr/bin/* root

User
john

can still run
/usr/bin/passwd root

if
fast_glob

is enabled by changing to
/usr/bin

and running
./passwd root

instead.
 

Preventing shell escapes

Once
sudo

executes a program, that program is free to do whatever
it pleases, including run other programs.
This can be a security issue since it is not uncommon for a program to
allow shell escapes, which lets a user bypass
sudo ‘s

access control and logging.
Common programs that permit shell escapes include shells (obviously),
editors, paginators, mail and terminal programs.

There are two basic approaches to this problem:


restrict

Avoid giving users access to commands that allow the user to run
arbitrary commands.
Many editors have a restricted mode where shell
escapes are disabled, though
sudoedit

is a better solution to
running editors via
sudo

Due to the large number of programs that
offer shell escapes, restricting users to the set of programs that
do not is often unworkable.

noexec

Many systems that support shared libraries have the ability to
override default library functions by pointing an environment
variable (usually
LD_PRELOAD

to an alternate shared library.
On such systems,
sudo ‘s

noexec

functionality can be used to prevent a program run by
sudo

from executing any other programs.
Note, however, that this applies only to native dynamically-linked
executables.
Statically-linked executables and foreign executables
running under binary emulation are not affected.

The
noexec

feature is known to work on SunOS, Solaris, *BSD,
Linux, IRIX, Tru64 UNIX, MacOS X, HP-UX 11.x and AIX 5.3 and above.
It should be supported on most operating systems that support the
LD_PRELOAD

environment variable.
Check your operating system’s manual pages for the dynamic linker
(usually ld.so, ld.so.1, dyld, dld.sl, rld, or loader) to see if
LD_PRELOAD

is supported.

To enable
noexec

for a command, use the
NOEXEC

tag as documented
in the User Specification section above.
Here is that example again:


aaron shanty = NOEXEC: /usr/bin/more, /usr/bin/vi

This allows user
aaron

to run
/usr/bin/more

and
/usr/bin/vi

with
noexec

enabled.
This will prevent those two commands from
executing other commands (such as a shell).
If you are unsure whether or not your system is capable of supporting
noexec

you can always just try it out and check whether shell escapes work when
noexec

is enabled.


Note that restricting shell escapes is not a panacea.
Programs running as root are still capable of many potentially hazardous
operations (such as changing or overwriting files) that could lead
to unintended privilege escalation.
In the specific case of an editor, a safer approach is to give the
user permission to run
sudoedit

 

Time stamp file checks

sudoers

will check the ownership of its time stamp directory
Po /var/db/sudo

by default
Pc and ignore the directory’s contents if it is not owned by root or

if it is writable by a user other than root.
On systems that allow non-root users to give away files via
chown(2),

if the time stamp directory is located in a world-writable
directory (e.g.,
/tmp )

it is possible for a user to create the time stamp directory before
sudo

is run.
However, because
sudoers

checks the ownership and mode of the directory and its
contents, the only damage that can be done is to
“hide”

files by putting them in the time stamp dir.
This is unlikely to happen since once the time stamp dir is owned by root
and inaccessible by any other user, the user placing files there would be
unable to get them back out.

sudoers

will not honor time stamps set far in the future.
Time stamps with a date greater than current_time + 2 *
TIMEOUT

will be ignored and sudo will log and complain.
This is done to keep a user from creating his/her own time stamp with a
bogus date on systems that allow users to give away files if the time
stamp directory is located in a world-writable directory.

On systems where the boot time is available,
sudoers

will ignore time stamps that date from before the machine booted.

Since time stamp files live in the file system, they can outlive a
user’s login session.
As a result, a user may be able to login, run a command with
sudo

after authenticating, logout, login again, and run
sudo

without authenticating so long as the time stamp file’s modification
time is within
5

minutes (or whatever the timeout is set to in
sudoers )

When the
tty_tickets

option is enabled, the time stamp has per-tty granularity but still
may outlive the user’s session.
On Linux systems where the devpts filesystem is used, Solaris systems
with the devices filesystem, as well as other systems that utilize a
devfs filesystem that monotonically increase the inode number of devices
as they are created (such as Mac OS X),
sudoers

is able to determine when a tty-based time stamp file is stale and will
ignore it.
Administrators should not rely on this feature as it is not universally
available.
 

SEE ALSO

ssh(1),

su(1),

fnmatch(3),

glob(3),

mktemp(3),

strftime(3),

sudoers.ldap5,

sudo_plugin8,

sudo(8),

visudo(8)

 

CAVEATS

The
sudoers

file should
always

be edited by the
visudo

command which locks the file and does grammatical checking.
It is
imperative that
sudoers

be free of syntax errors since
sudo

will not run with a syntactically incorrect
sudoers

file.

When using netgroups of machines (as opposed to users), if you
store fully qualified host name in the netgroup (as is usually the
case), you either need to have the machine’s host name be fully qualified
as returned by the
hostname

command or use the
fqdn

option in
sudoers

 

BUGS

If you feel you have found a bug in
sudo

please submit a bug report at http://www.sudo.ws/sudo/bugs/
 

SUPPORT

Limited free support is available via the sudo-users mailing list,
see http://www.sudo.ws/mailman/listinfo/sudo-users to subscribe or
search the archives.
 

DISCLAIMER

sudo

is provided
“AS IS”

and any express or implied warranties, including, but not limited
to, the implied warranties of merchantability and fitness for a
particular purpose are disclaimed.
See the LICENSE file distributed with
sudo

or http://www.sudo.ws/sudo/license.html for complete details.



 

Index



NAME

DESCRIPTION


Authentication and logging

Command environment


SUDOERS FILE FORMAT


Quick guide to EBNF

Aliases

Defaults

User specification

Runas_Spec

SELinux_Spec

Tag_Spec

Wildcards

Exceptions to wildcard rules

Including other files from within sudoers

Other special characters and reserved words


SUDOERS OPTIONS

LOG FORMAT


Accepted command log entries

Denied command log entries

Error log entries

Notes on logging via syslog

Notes on logging to a file


SUDO.CONF


Plugin options

Debug flags


FILES

EXAMPLES

SECURITY NOTES


Limitations of the So ! Sc operator

Security implications of Em fast_glob

Preventing shell escapes

Time stamp file checks


SEE ALSO

CAVEATS

BUGS

SUPPORT

DISCLAIMER



Back to Top

PayPal Logo┬ęCheap VPS LLC - Leader of affordable VPS Hosting Services