blob: 1702b47888725d7bb27c239cd1822d79a681b8ba [file] [log] [blame]
/*
* libxt_owner - iptables addon for xt_owner
*
* Copyright © CC Computer Consultants GmbH, 2007 - 2008
* Jan Engelhardt <jengelh@computergmbh.de>
*/
#include <grp.h>
#include <pwd.h>
#include <stdbool.h>
#include <stdio.h>
#include <limits.h>
#include <xtables.h>
#include <linux/netfilter/xt_owner.h>
/* match and invert flags */
enum {
IPT_OWNER_UID = 0x01,
IPT_OWNER_GID = 0x02,
IPT_OWNER_PID = 0x04,
IPT_OWNER_SID = 0x08,
IPT_OWNER_COMM = 0x10,
IP6T_OWNER_UID = IPT_OWNER_UID,
IP6T_OWNER_GID = IPT_OWNER_GID,
IP6T_OWNER_PID = IPT_OWNER_PID,
IP6T_OWNER_SID = IPT_OWNER_SID,
IP6T_OWNER_COMM = IPT_OWNER_COMM,
};
struct ipt_owner_info {
uid_t uid;
gid_t gid;
pid_t pid;
pid_t sid;
char comm[16];
uint8_t match, invert; /* flags */
};
struct ip6t_owner_info {
uid_t uid;
gid_t gid;
pid_t pid;
pid_t sid;
char comm[16];
uint8_t match, invert; /* flags */
};
/*
* Note: "UINT32_MAX - 1" is used in the code because -1 is a reserved
* UID/GID value anyway.
*/
enum {
O_USER = 0,
O_GROUP,
O_SOCK_EXISTS,
O_PROCESS,
O_SESSION,
O_COMM,
O_SUPPL_GROUPS,
};
static void owner_mt_help_v0(void)
{
printf(
"owner match options:\n"
"[!] --uid-owner userid Match local UID\n"
"[!] --gid-owner groupid Match local GID\n"
"[!] --pid-owner processid Match local PID\n"
"[!] --sid-owner sessionid Match local SID\n"
"[!] --cmd-owner name Match local command name\n"
"NOTE: PID, SID and command matching are broken on SMP\n");
}
static void owner_mt6_help_v0(void)
{
printf(
"owner match options:\n"
"[!] --uid-owner userid Match local UID\n"
"[!] --gid-owner groupid Match local GID\n"
"[!] --pid-owner processid Match local PID\n"
"[!] --sid-owner sessionid Match local SID\n"
"NOTE: PID and SID matching are broken on SMP\n");
}
static void owner_mt_help(void)
{
printf(
"owner match options:\n"
"[!] --uid-owner userid[-userid] Match local UID\n"
"[!] --gid-owner groupid[-groupid] Match local GID\n"
"[!] --socket-exists Match if socket exists\n"
" --suppl-groups Also match supplementary groups set with --gid-owner\n");
}
#define s struct ipt_owner_info
static const struct xt_option_entry owner_mt_opts_v0[] = {
{.name = "uid-owner", .id = O_USER, .type = XTTYPE_STRING,
.flags = XTOPT_INVERT},
{.name = "gid-owner", .id = O_GROUP, .type = XTTYPE_STRING,
.flags = XTOPT_INVERT},
{.name = "pid-owner", .id = O_PROCESS, .type = XTTYPE_UINT32,
.flags = XTOPT_INVERT | XTOPT_PUT, XTOPT_POINTER(s, pid),
.max = INT_MAX},
{.name = "sid-owner", .id = O_SESSION, .type = XTTYPE_UINT32,
.flags = XTOPT_INVERT | XTOPT_PUT, XTOPT_POINTER(s, sid),
.max = INT_MAX},
{.name = "cmd-owner", .id = O_COMM, .type = XTTYPE_STRING,
.flags = XTOPT_INVERT | XTOPT_PUT, XTOPT_POINTER(s, comm)},
XTOPT_TABLEEND,
};
#undef s
#define s struct ip6t_owner_info
static const struct xt_option_entry owner_mt6_opts_v0[] = {
{.name = "uid-owner", .id = O_USER, .type = XTTYPE_STRING,
.flags = XTOPT_INVERT},
{.name = "gid-owner", .id = O_GROUP, .type = XTTYPE_STRING,
.flags = XTOPT_INVERT},
{.name = "pid-owner", .id = O_PROCESS, .type = XTTYPE_UINT32,
.flags = XTOPT_INVERT | XTOPT_PUT, XTOPT_POINTER(s, pid),
.max = INT_MAX},
{.name = "sid-owner", .id = O_SESSION, .type = XTTYPE_UINT32,
.flags = XTOPT_INVERT | XTOPT_PUT, XTOPT_POINTER(s, sid),
.max = INT_MAX},
XTOPT_TABLEEND,
};
#undef s
static const struct xt_option_entry owner_mt_opts[] = {
{.name = "uid-owner", .id = O_USER, .type = XTTYPE_STRING,
.flags = XTOPT_INVERT},
{.name = "gid-owner", .id = O_GROUP, .type = XTTYPE_STRING,
.flags = XTOPT_INVERT},
{.name = "socket-exists", .id = O_SOCK_EXISTS, .type = XTTYPE_NONE,
.flags = XTOPT_INVERT},
{.name = "suppl-groups", .id = O_SUPPL_GROUPS, .type = XTTYPE_NONE},
XTOPT_TABLEEND,
};
static void owner_mt_parse_v0(struct xt_option_call *cb)
{
struct ipt_owner_info *info = cb->data;
struct passwd *pwd;
struct group *grp;
unsigned int id;
xtables_option_parse(cb);
switch (cb->entry->id) {
case O_USER:
if ((pwd = getpwnam(cb->arg)) != NULL)
id = pwd->pw_uid;
else if (!xtables_strtoui(cb->arg, NULL, &id, 0, UINT32_MAX - 1))
xtables_param_act(XTF_BAD_VALUE, "owner", "--uid-owner", cb->arg);
if (cb->invert)
info->invert |= IPT_OWNER_UID;
info->match |= IPT_OWNER_UID;
info->uid = id;
break;
case O_GROUP:
if ((grp = getgrnam(cb->arg)) != NULL)
id = grp->gr_gid;
else if (!xtables_strtoui(cb->arg, NULL, &id, 0, UINT32_MAX - 1))
xtables_param_act(XTF_BAD_VALUE, "owner", "--gid-owner", cb->arg);
if (cb->invert)
info->invert |= IPT_OWNER_GID;
info->match |= IPT_OWNER_GID;
info->gid = id;
break;
case O_PROCESS:
if (cb->invert)
info->invert |= IPT_OWNER_PID;
info->match |= IPT_OWNER_PID;
break;
case O_SESSION:
if (cb->invert)
info->invert |= IPT_OWNER_SID;
info->match |= IPT_OWNER_SID;
break;
case O_COMM:
if (cb->invert)
info->invert |= IPT_OWNER_COMM;
info->match |= IPT_OWNER_COMM;
break;
}
}
static void owner_mt6_parse_v0(struct xt_option_call *cb)
{
struct ip6t_owner_info *info = cb->data;
struct passwd *pwd;
struct group *grp;
unsigned int id;
xtables_option_parse(cb);
switch (cb->entry->id) {
case O_USER:
if ((pwd = getpwnam(cb->arg)) != NULL)
id = pwd->pw_uid;
else if (!xtables_strtoui(cb->arg, NULL, &id, 0, UINT32_MAX - 1))
xtables_param_act(XTF_BAD_VALUE, "owner", "--uid-owner", cb->arg);
if (cb->invert)
info->invert |= IP6T_OWNER_UID;
info->match |= IP6T_OWNER_UID;
info->uid = id;
break;
case O_GROUP:
if ((grp = getgrnam(cb->arg)) != NULL)
id = grp->gr_gid;
else if (!xtables_strtoui(cb->arg, NULL, &id, 0, UINT32_MAX - 1))
xtables_param_act(XTF_BAD_VALUE, "owner", "--gid-owner", cb->arg);
if (cb->invert)
info->invert |= IP6T_OWNER_GID;
info->match |= IP6T_OWNER_GID;
info->gid = id;
break;
case O_PROCESS:
if (cb->invert)
info->invert |= IP6T_OWNER_PID;
info->match |= IP6T_OWNER_PID;
break;
case O_SESSION:
if (cb->invert)
info->invert |= IP6T_OWNER_SID;
info->match |= IP6T_OWNER_SID;
break;
}
}
static void owner_parse_range(const char *s, unsigned int *from,
unsigned int *to, const char *opt)
{
char *end;
/* -1 is reversed, so the max is one less than that. */
if (!xtables_strtoui(s, &end, from, 0, UINT32_MAX - 1))
xtables_param_act(XTF_BAD_VALUE, "owner", opt, s);
*to = *from;
if (*end == '-' || *end == ':')
if (!xtables_strtoui(end + 1, &end, to, 0, UINT32_MAX - 1))
xtables_param_act(XTF_BAD_VALUE, "owner", opt, s);
if (*end != '\0')
xtables_param_act(XTF_BAD_VALUE, "owner", opt, s);
}
static void owner_mt_parse(struct xt_option_call *cb)
{
struct xt_owner_match_info *info = cb->data;
struct passwd *pwd;
struct group *grp;
unsigned int from, to;
xtables_option_parse(cb);
switch (cb->entry->id) {
case O_USER:
if ((pwd = getpwnam(cb->arg)) != NULL)
from = to = pwd->pw_uid;
else
owner_parse_range(cb->arg, &from, &to, "--uid-owner");
if (cb->invert)
info->invert |= XT_OWNER_UID;
info->match |= XT_OWNER_UID;
info->uid_min = from;
info->uid_max = to;
break;
case O_GROUP:
if ((grp = getgrnam(cb->arg)) != NULL)
from = to = grp->gr_gid;
else
owner_parse_range(cb->arg, &from, &to, "--gid-owner");
if (cb->invert)
info->invert |= XT_OWNER_GID;
info->match |= XT_OWNER_GID;
info->gid_min = from;
info->gid_max = to;
break;
case O_SOCK_EXISTS:
if (cb->invert)
info->invert |= XT_OWNER_SOCKET;
info->match |= XT_OWNER_SOCKET;
break;
case O_SUPPL_GROUPS:
if (!(info->match & XT_OWNER_GID))
xtables_param_act(XTF_BAD_VALUE, "owner", "--suppl-groups", "you need to use --gid-owner first");
info->match |= XT_OWNER_SUPPL_GROUPS;
break;
}
}
static void owner_mt_check(struct xt_fcheck_call *cb)
{
if (cb->xflags == 0)
xtables_error(PARAMETER_PROBLEM, "owner: At least one of "
"--uid-owner, --gid-owner or --socket-exists "
"is required");
}
static void
owner_mt_print_item_v0(const struct ipt_owner_info *info, const char *label,
uint8_t flag, bool numeric)
{
if (!(info->match & flag))
return;
if (info->invert & flag)
printf(" !");
printf(" %s", label);
switch (info->match & flag) {
case IPT_OWNER_UID:
if (!numeric) {
struct passwd *pwd = getpwuid(info->uid);
if (pwd != NULL && pwd->pw_name != NULL) {
printf(" %s", pwd->pw_name);
break;
}
}
printf(" %u", (unsigned int)info->uid);
break;
case IPT_OWNER_GID:
if (!numeric) {
struct group *grp = getgrgid(info->gid);
if (grp != NULL && grp->gr_name != NULL) {
printf(" %s", grp->gr_name);
break;
}
}
printf(" %u", (unsigned int)info->gid);
break;
case IPT_OWNER_PID:
printf(" %u", (unsigned int)info->pid);
break;
case IPT_OWNER_SID:
printf(" %u", (unsigned int)info->sid);
break;
case IPT_OWNER_COMM:
printf(" %.*s", (int)sizeof(info->comm), info->comm);
break;
}
}
static void
owner_mt6_print_item_v0(const struct ip6t_owner_info *info, const char *label,
uint8_t flag, bool numeric)
{
if (!(info->match & flag))
return;
if (info->invert & flag)
printf(" !");
printf(" %s", label);
switch (info->match & flag) {
case IP6T_OWNER_UID:
if (!numeric) {
struct passwd *pwd = getpwuid(info->uid);
if (pwd != NULL && pwd->pw_name != NULL) {
printf(" %s", pwd->pw_name);
break;
}
}
printf(" %u", (unsigned int)info->uid);
break;
case IP6T_OWNER_GID:
if (!numeric) {
struct group *grp = getgrgid(info->gid);
if (grp != NULL && grp->gr_name != NULL) {
printf(" %s", grp->gr_name);
break;
}
}
printf(" %u", (unsigned int)info->gid);
break;
case IP6T_OWNER_PID:
printf(" %u", (unsigned int)info->pid);
break;
case IP6T_OWNER_SID:
printf(" %u", (unsigned int)info->sid);
break;
}
}
static void
owner_mt_print_item(const struct xt_owner_match_info *info, const char *label,
uint8_t flag, bool numeric)
{
if (!(info->match & flag))
return;
if (info->invert & flag)
printf(" !");
printf(" %s", label);
switch (info->match & flag) {
case XT_OWNER_UID:
if (info->uid_min != info->uid_max) {
printf(" %u-%u", (unsigned int)info->uid_min,
(unsigned int)info->uid_max);
break;
} else if (!numeric) {
const struct passwd *pwd = getpwuid(info->uid_min);
if (pwd != NULL && pwd->pw_name != NULL) {
printf(" %s", pwd->pw_name);
break;
}
}
printf(" %u", (unsigned int)info->uid_min);
break;
case XT_OWNER_GID:
if (info->gid_min != info->gid_max) {
printf(" %u-%u", (unsigned int)info->gid_min,
(unsigned int)info->gid_max);
break;
} else if (!numeric) {
const struct group *grp = getgrgid(info->gid_min);
if (grp != NULL && grp->gr_name != NULL) {
printf(" %s", grp->gr_name);
break;
}
}
printf(" %u", (unsigned int)info->gid_min);
break;
}
}
static void
owner_mt_print_v0(const void *ip, const struct xt_entry_match *match,
int numeric)
{
const struct ipt_owner_info *info = (void *)match->data;
owner_mt_print_item_v0(info, "owner UID match", IPT_OWNER_UID, numeric);
owner_mt_print_item_v0(info, "owner GID match", IPT_OWNER_GID, numeric);
owner_mt_print_item_v0(info, "owner PID match", IPT_OWNER_PID, numeric);
owner_mt_print_item_v0(info, "owner SID match", IPT_OWNER_SID, numeric);
owner_mt_print_item_v0(info, "owner CMD match", IPT_OWNER_COMM, numeric);
}
static void
owner_mt6_print_v0(const void *ip, const struct xt_entry_match *match,
int numeric)
{
const struct ip6t_owner_info *info = (void *)match->data;
owner_mt6_print_item_v0(info, "owner UID match", IPT_OWNER_UID, numeric);
owner_mt6_print_item_v0(info, "owner GID match", IPT_OWNER_GID, numeric);
owner_mt6_print_item_v0(info, "owner PID match", IPT_OWNER_PID, numeric);
owner_mt6_print_item_v0(info, "owner SID match", IPT_OWNER_SID, numeric);
}
static void owner_mt_print(const void *ip, const struct xt_entry_match *match,
int numeric)
{
const struct xt_owner_match_info *info = (void *)match->data;
owner_mt_print_item(info, "owner socket exists", XT_OWNER_SOCKET, numeric);
owner_mt_print_item(info, "owner UID match", XT_OWNER_UID, numeric);
owner_mt_print_item(info, "owner GID match", XT_OWNER_GID, numeric);
owner_mt_print_item(info, "incl. suppl. groups", XT_OWNER_SUPPL_GROUPS, numeric);
}
static void
owner_mt_save_v0(const void *ip, const struct xt_entry_match *match)
{
const struct ipt_owner_info *info = (void *)match->data;
owner_mt_print_item_v0(info, "--uid-owner", IPT_OWNER_UID, true);
owner_mt_print_item_v0(info, "--gid-owner", IPT_OWNER_GID, true);
owner_mt_print_item_v0(info, "--pid-owner", IPT_OWNER_PID, true);
owner_mt_print_item_v0(info, "--sid-owner", IPT_OWNER_SID, true);
owner_mt_print_item_v0(info, "--cmd-owner", IPT_OWNER_COMM, true);
}
static void
owner_mt6_save_v0(const void *ip, const struct xt_entry_match *match)
{
const struct ip6t_owner_info *info = (void *)match->data;
owner_mt6_print_item_v0(info, "--uid-owner", IPT_OWNER_UID, true);
owner_mt6_print_item_v0(info, "--gid-owner", IPT_OWNER_GID, true);
owner_mt6_print_item_v0(info, "--pid-owner", IPT_OWNER_PID, true);
owner_mt6_print_item_v0(info, "--sid-owner", IPT_OWNER_SID, true);
}
static void owner_mt_save(const void *ip, const struct xt_entry_match *match)
{
const struct xt_owner_match_info *info = (void *)match->data;
owner_mt_print_item(info, "--socket-exists", XT_OWNER_SOCKET, true);
owner_mt_print_item(info, "--uid-owner", XT_OWNER_UID, true);
owner_mt_print_item(info, "--gid-owner", XT_OWNER_GID, true);
owner_mt_print_item(info, "--suppl-groups", XT_OWNER_SUPPL_GROUPS, true);
}
static int
owner_mt_print_uid_xlate(const struct xt_owner_match_info *info,
struct xt_xlate *xl)
{
xt_xlate_add(xl, "skuid%s ", info->invert ? " !=" : "");
if (info->uid_min != info->uid_max)
xt_xlate_add(xl, "%u-%u", (unsigned int)info->uid_min,
(unsigned int)info->uid_max);
else
xt_xlate_add(xl, "%u", (unsigned int)info->uid_min);
return 1;
}
static int
owner_mt_print_gid_xlate(const struct xt_owner_match_info *info,
struct xt_xlate *xl)
{
xt_xlate_add(xl, "skgid%s ", info->invert ? " !=" : "");
if (info->gid_min != info->gid_max)
xt_xlate_add(xl, "%u-%u", (unsigned int)info->gid_min,
(unsigned int)info->gid_max);
else
xt_xlate_add(xl, "%u", (unsigned int)info->gid_min);
return 1;
}
static int owner_mt_xlate(struct xt_xlate *xl,
const struct xt_xlate_mt_params *params)
{
const struct xt_owner_match_info *info = (void *)params->match->data;
int ret;
switch (info->match) {
case XT_OWNER_UID:
ret = owner_mt_print_uid_xlate(info, xl);
break;
case XT_OWNER_GID:
ret = owner_mt_print_gid_xlate(info, xl);
break;
default:
ret = 0;
}
return ret;
}
static struct xtables_match owner_mt_reg[] = {
{
.version = XTABLES_VERSION,
.name = "owner",
.revision = 0,
.family = NFPROTO_IPV4,
.size = XT_ALIGN(sizeof(struct ipt_owner_info)),
.userspacesize = XT_ALIGN(sizeof(struct ipt_owner_info)),
.help = owner_mt_help_v0,
.x6_parse = owner_mt_parse_v0,
.x6_fcheck = owner_mt_check,
.print = owner_mt_print_v0,
.save = owner_mt_save_v0,
.x6_options = owner_mt_opts_v0,
},
{
.version = XTABLES_VERSION,
.name = "owner",
.revision = 0,
.family = NFPROTO_IPV6,
.size = XT_ALIGN(sizeof(struct ip6t_owner_info)),
.userspacesize = XT_ALIGN(sizeof(struct ip6t_owner_info)),
.help = owner_mt6_help_v0,
.x6_parse = owner_mt6_parse_v0,
.x6_fcheck = owner_mt_check,
.print = owner_mt6_print_v0,
.save = owner_mt6_save_v0,
.x6_options = owner_mt6_opts_v0,
},
{
.version = XTABLES_VERSION,
.name = "owner",
.revision = 1,
.family = NFPROTO_UNSPEC,
.size = XT_ALIGN(sizeof(struct xt_owner_match_info)),
.userspacesize = XT_ALIGN(sizeof(struct xt_owner_match_info)),
.help = owner_mt_help,
.x6_parse = owner_mt_parse,
.x6_fcheck = owner_mt_check,
.print = owner_mt_print,
.save = owner_mt_save,
.x6_options = owner_mt_opts,
.xlate = owner_mt_xlate,
},
};
void _init(void)
{
xtables_register_matches(owner_mt_reg, ARRAY_SIZE(owner_mt_reg));
}