usr.sbin/ftp-proxy/filter.c

   1 /*      $OpenBSD: filter.c,v 1.6 2007/08/01 09:31:41 henning Exp $ */
   2
   3 /*
   4  * Copyright (c) 2004, 2005 Camiel Dobbelaar, <cd@sentia.nl>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #define _KERNEL_STRUCTURES
  20 #include <sys/ioctl.h>
  21 #include <sys/types.h>
  22 #include <sys/socket.h>
  23
  24 #include <net/if.h>
  25 #include <net/pf/pfvar.h>
  26 #include <netinet/in.h>
  27 #include <netinet/tcp.h>
  28 #include <arpa/inet.h>
  29
  30 #include <err.h>
  31 #include <errno.h>
  32 #include <fcntl.h>
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <unistd.h>
  36
  37 #include "filter.h"
  38
  39 /* From netinet/in.h, but only _KERNEL_ gets them. */
  40 #define satosin(sa)     ((struct sockaddr_in *)(sa))
  41 #define satosin6(sa)    ((struct sockaddr_in6 *)(sa))
  42
  43 enum { TRANS_FILTER = 0, TRANS_NAT, TRANS_RDR, TRANS_SIZE };
  44
  45 int prepare_rule(u_int32_t, int, struct sockaddr *, struct sockaddr *,
  46     u_int16_t);
  47 int server_lookup4(struct sockaddr_in *, struct sockaddr_in *,
  48     struct sockaddr_in *);
  49 int server_lookup6(struct sockaddr_in6 *, struct sockaddr_in6 *,
  50     struct sockaddr_in6 *);
  51
  52 static struct pfioc_pooladdr    pfp;
  53 static struct pfioc_rule        pfr;
  54 static struct pfioc_trans       pft;
  55 static struct pfioc_trans_e     pfte[TRANS_SIZE];
  56 static int dev, rule_log;
  57 static char *qname, *tagname;
  58
  59 int
  60 add_filter(u_int32_t id, u_int8_t dir, struct sockaddr *src,
  61     struct sockaddr *dst, u_int16_t d_port)
  62 {
  63         if (!src || !dst || !d_port) {
  64                 errno = EINVAL;
  65                 return (-1);
  66         }
  67
  68         if (prepare_rule(id, PF_RULESET_FILTER, src, dst, d_port) == -1)
  69                 return (-1);
  70
  71         pfr.rule.direction = dir;
  72         if (ioctl(dev, DIOCADDRULE, &pfr) == -1)
  73                 return (-1);
  74
  75         return (0);
  76 }
  77
  78 int
  79 add_nat(u_int32_t id, struct sockaddr *src, struct sockaddr *dst,
  80     u_int16_t d_port, struct sockaddr *nat, u_int16_t nat_range_low,
  81     u_int16_t nat_range_high)
  82 {
  83         if (!src || !dst || !d_port || !nat || !nat_range_low ||
  84             (src->sa_family != nat->sa_family)) {
  85                 errno = EINVAL;
  86                 return (-1);
  87         }
  88
  89         if (prepare_rule(id, PF_RULESET_NAT, src, dst, d_port) == -1)
  90                 return (-1);
  91
  92         if (nat->sa_family == AF_INET) {
  93                 memcpy(&pfp.addr.addr.v.a.addr.v4,
  94                     &satosin(nat)->sin_addr.s_addr, 4);
  95                 memset(&pfp.addr.addr.v.a.mask.addr8, 255, 4);
  96         } else {
  97                 memcpy(&pfp.addr.addr.v.a.addr.v6,
  98                     &satosin6(nat)->sin6_addr.s6_addr, 16);
  99                 memset(&pfp.addr.addr.v.a.mask.addr8, 255, 16);
 100         }
 101         if (ioctl(dev, DIOCADDADDR, &pfp) == -1)
 102                 return (-1);
 103
 104         pfr.rule.rpool.proxy_port[0] = nat_range_low;
 105         pfr.rule.rpool.proxy_port[1] = nat_range_high;
 106         if (ioctl(dev, DIOCADDRULE, &pfr) == -1)
 107                 return (-1);
 108
 109         return (0);
 110 }
 111
 112 int
 113 add_rdr(u_int32_t id, struct sockaddr *src, struct sockaddr *dst,
 114     u_int16_t d_port, struct sockaddr *rdr, u_int16_t rdr_port)
 115 {
 116         if (!src || !dst || !d_port || !rdr || !rdr_port ||
 117             (src->sa_family != rdr->sa_family)) {
 118                 errno = EINVAL;
 119                 return (-1);
 120         }
 121
 122         if (prepare_rule(id, PF_RULESET_RDR, src, dst, d_port) == -1)
 123                 return (-1);
 124
 125         if (rdr->sa_family == AF_INET) {
 126                 memcpy(&pfp.addr.addr.v.a.addr.v4,
 127                     &satosin(rdr)->sin_addr.s_addr, 4);
 128                 memset(&pfp.addr.addr.v.a.mask.addr8, 255, 4);
 129         } else {
 130                 memcpy(&pfp.addr.addr.v.a.addr.v6,
 131                     &satosin6(rdr)->sin6_addr.s6_addr, 16);
 132                 memset(&pfp.addr.addr.v.a.mask.addr8, 255, 16);
 133         }
 134         if (ioctl(dev, DIOCADDADDR, &pfp) == -1)
 135                 return (-1);
 136
 137         pfr.rule.rpool.proxy_port[0] = rdr_port;
 138         if (ioctl(dev, DIOCADDRULE, &pfr) == -1)
 139                 return (-1);
 140
 141         return (0);
 142 }
 143
 144 int
 145 do_commit(void)
 146 {
 147         if (ioctl(dev, DIOCXCOMMIT, &pft) == -1)
 148                 return (-1);
 149
 150         return (0);
 151 }
 152
 153 int
 154 do_rollback(void)
 155 {
 156         if (ioctl(dev, DIOCXROLLBACK, &pft) == -1)
 157                 return (-1);
 158
 159         return (0);
 160 }
 161
 162 void
 163 init_filter(char *opt_qname, char *opt_tagname, int opt_verbose)
 164 {
 165         struct pf_status status;
 166
 167         qname = opt_qname;
 168         tagname = opt_tagname;
 169
 170         if (opt_verbose == 1)
 171                 rule_log = PF_LOG;
 172         else if (opt_verbose == 2)
 173                 rule_log = PF_LOG_ALL;
 174
 175         dev = open("/dev/pf", O_RDWR);
 176         if (dev == -1)
 177                 err(1, "/dev/pf");
 178         if (ioctl(dev, DIOCGETSTATUS, &status) == -1)
 179                 err(1, "DIOCGETSTATUS");
 180         if (!status.running)
 181                 errx(1, "pf is disabled");
 182 }
 183
 184 int
 185 prepare_commit(u_int32_t id)
 186 {
 187         char an[PF_ANCHOR_NAME_SIZE];
 188         int i;
 189
 190         memset(&pft, 0, sizeof pft);
 191         pft.size = TRANS_SIZE;
 192         pft.esize = sizeof pfte[0];
 193         pft.array = pfte;
 194
 195         snprintf(an, PF_ANCHOR_NAME_SIZE, "%s/%d.%d", FTP_PROXY_ANCHOR,
 196             getpid(), id);
 197         for (i = 0; i < TRANS_SIZE; i++) {
 198                 memset(&pfte[i], 0, sizeof pfte[0]);
 199                 strlcpy(pfte[i].anchor, an, PF_ANCHOR_NAME_SIZE);
 200                 switch (i) {
 201                 case TRANS_FILTER:
 202                         pfte[i].rs_num = PF_RULESET_FILTER;
 203                         break;
 204                 case TRANS_NAT:
 205                         pfte[i].rs_num = PF_RULESET_NAT;
 206                         break;
 207                 case TRANS_RDR:
 208                         pfte[i].rs_num = PF_RULESET_RDR;
 209                         break;
 210                 default:
 211                         errno = EINVAL;
 212                         return (-1);
 213                 }
 214         }
 215
 216         if (ioctl(dev, DIOCXBEGIN, &pft) == -1)
 217                 return (-1);
 218
 219         return (0);
 220 }
 221
 222 int
 223 prepare_rule(u_int32_t id, int rs_num, struct sockaddr *src,
 224     struct sockaddr *dst, u_int16_t d_port)
 225 {
 226         char an[PF_ANCHOR_NAME_SIZE];
 227
 228         if ((src->sa_family != AF_INET && src->sa_family != AF_INET6) ||
 229             (src->sa_family != dst->sa_family)) {
 230                 errno = EPROTONOSUPPORT;
 231                 return (-1);
 232         }
 233
 234         memset(&pfp, 0, sizeof pfp);
 235         memset(&pfr, 0, sizeof pfr);
 236         snprintf(an, PF_ANCHOR_NAME_SIZE, "%s/%d.%d", FTP_PROXY_ANCHOR,
 237             getpid(), id);
 238         strlcpy(pfp.anchor, an, PF_ANCHOR_NAME_SIZE);
 239         strlcpy(pfr.anchor, an, PF_ANCHOR_NAME_SIZE);
 240
 241         switch (rs_num) {
 242         case PF_RULESET_FILTER:
 243                 pfr.ticket = pfte[TRANS_FILTER].ticket;
 244                 break;
 245         case PF_RULESET_NAT:
 246                 pfr.ticket = pfte[TRANS_NAT].ticket;
 247                 break;
 248         case PF_RULESET_RDR:
 249                 pfr.ticket = pfte[TRANS_RDR].ticket;
 250                 break;
 251         default:
 252                 errno = EINVAL;
 253                 return (-1);
 254         }
 255         if (ioctl(dev, DIOCBEGINADDRS, &pfp) == -1)
 256                 return (-1);
 257         pfr.pool_ticket = pfp.ticket;
 258
 259         /* Generic for all rule types. */
 260         pfr.rule.af = src->sa_family;
 261         pfr.rule.proto = IPPROTO_TCP;
 262         pfr.rule.src.addr.type = PF_ADDR_ADDRMASK;
 263         pfr.rule.dst.addr.type = PF_ADDR_ADDRMASK;
 264         if (src->sa_family == AF_INET) {
 265                 memcpy(&pfr.rule.src.addr.v.a.addr.v4,
 266                     &satosin(src)->sin_addr.s_addr, 4);
 267                 memset(&pfr.rule.src.addr.v.a.mask.addr8, 255, 4);
 268                 memcpy(&pfr.rule.dst.addr.v.a.addr.v4,
 269                     &satosin(dst)->sin_addr.s_addr, 4);
 270                 memset(&pfr.rule.dst.addr.v.a.mask.addr8, 255, 4);
 271         } else {
 272                 memcpy(&pfr.rule.src.addr.v.a.addr.v6,
 273                     &satosin6(src)->sin6_addr.s6_addr, 16);
 274                 memset(&pfr.rule.src.addr.v.a.mask.addr8, 255, 16);
 275                 memcpy(&pfr.rule.dst.addr.v.a.addr.v6,
 276                     &satosin6(dst)->sin6_addr.s6_addr, 16);
 277                 memset(&pfr.rule.dst.addr.v.a.mask.addr8, 255, 16);
 278         }
 279         pfr.rule.dst.port_op = PF_OP_EQ;
 280         pfr.rule.dst.port[0] = htons(d_port);
 281         if (tagname != NULL)
 282                 strlcpy(pfr.rule.tagname, tagname, sizeof pfr.rule.tagname);
 283
 284         switch (rs_num) {
 285         case PF_RULESET_FILTER:
 286                 /*
 287                  * pass quick [log] inet[6] proto tcp \
 288                  *     from $src to $dst port = $d_port flags S/SA keep state
 289                  *     (max 1) [queue qname]
 290                  */
 291                 pfr.rule.action = PF_PASS;
 292                 pfr.rule.quick = 1;
 293                 pfr.rule.log = rule_log;
 294                 pfr.rule.keep_state = 1;
 295                 pfr.rule.flags = TH_SYN;
 296                 pfr.rule.flagset = (TH_SYN|TH_ACK);
 297                 pfr.rule.max_states = 1;
 298                 if (qname != NULL)
 299                         strlcpy(pfr.rule.qname, qname, sizeof pfr.rule.qname);
 300                 break;
 301         case PF_RULESET_NAT:
 302                 /*
 303                  * nat inet[6] proto tcp from $src to $dst port $d_port -> $nat
 304                  */
 305                 pfr.rule.action = PF_NAT;
 306                 break;
 307         case PF_RULESET_RDR:
 308                 /*
 309                  * rdr inet[6] proto tcp from $src to $dst port $d_port -> $rdr
 310                  */
 311                 pfr.rule.action = PF_RDR;
 312                 break;
 313         default:
 314                 errno = EINVAL;
 315                 return (-1);
 316         }
 317
 318         return (0);
 319 }
 320
 321 int
 322 server_lookup(struct sockaddr *client, struct sockaddr *proxy,
 323     struct sockaddr *server)
 324 {
 325         if (client->sa_family == AF_INET)
 326                 return (server_lookup4(satosin(client), satosin(proxy),
 327                     satosin(server)));
 328
 329         if (client->sa_family == AF_INET6)
 330                 return (server_lookup6(satosin6(client), satosin6(proxy),
 331                     satosin6(server)));
 332
 333         errno = EPROTONOSUPPORT;
 334         return (-1);
 335 }
 336
 337 int
 338 server_lookup4(struct sockaddr_in *client, struct sockaddr_in *proxy,
 339     struct sockaddr_in *server)
 340 {
 341         struct pfioc_natlook pnl;
 342
 343         memset(&pnl, 0, sizeof pnl);
 344         pnl.direction = PF_OUT;
 345         pnl.af = AF_INET;
 346         pnl.proto = IPPROTO_TCP;
 347         memcpy(&pnl.saddr.v4, &client->sin_addr.s_addr, sizeof pnl.saddr.v4);
 348         memcpy(&pnl.daddr.v4, &proxy->sin_addr.s_addr, sizeof pnl.daddr.v4);
 349         pnl.sport = client->sin_port;
 350         pnl.dport = proxy->sin_port;
 351
 352         if (ioctl(dev, DIOCNATLOOK, &pnl) == -1)
 353                 return (-1);
 354
 355         memset(server, 0, sizeof(struct sockaddr_in));
 356         server->sin_len = sizeof(struct sockaddr_in);
 357         server->sin_family = AF_INET;
 358         memcpy(&server->sin_addr.s_addr, &pnl.rdaddr.v4,
 359             sizeof server->sin_addr.s_addr);
 360         server->sin_port = pnl.rdport;
 361
 362         return (0);
 363 }
 364
 365 int
 366 server_lookup6(struct sockaddr_in6 *client, struct sockaddr_in6 *proxy,
 367     struct sockaddr_in6 *server)
 368 {
 369         struct pfioc_natlook pnl;
 370
 371         memset(&pnl, 0, sizeof pnl);
 372         pnl.direction = PF_OUT;
 373         pnl.af = AF_INET6;
 374         pnl.proto = IPPROTO_TCP;
 375         memcpy(&pnl.saddr.v6, &client->sin6_addr.s6_addr, sizeof pnl.saddr.v6);
 376         memcpy(&pnl.daddr.v6, &proxy->sin6_addr.s6_addr, sizeof pnl.daddr.v6);
 377         pnl.sport = client->sin6_port;
 378         pnl.dport = proxy->sin6_port;
 379
 380         if (ioctl(dev, DIOCNATLOOK, &pnl) == -1)
 381                 return (-1);
 382
 383         memset(server, 0, sizeof(struct sockaddr_in6));
 384         server->sin6_len = sizeof(struct sockaddr_in6);
 385         server->sin6_family = AF_INET6;
 386         memcpy(&server->sin6_addr.s6_addr, &pnl.rdaddr.v6,
 387             sizeof server->sin6_addr);
 388         server->sin6_port = pnl.rdport;
 389
 390         return (0);
 391 }