modules/bpf_filter.c

   1 /*      From NetBSD: bpf_filter.c,v 1.12 1996/02/13 22:00:00 christos Exp */
   2
   3 /*
   4  * Copyright (c) 1990, 1991, 1992, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from the Stanford/CMU enet packet filter,
   8  * (net/enet.c) distributed as part of 4.3BSD, and code contributed
   9  * to Berkeley by Steven McCanne and Van Jacobson both of Lawrence
  10  * Berkeley Laboratory.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 3. All advertising materials mentioning features or use of this software
  21  *    must display the following acknowledgement:
  22  *      This product includes software developed by the University of
  23  *      California, Berkeley and its contributors.
  24  * 4. Neither the name of the University nor the names of its contributors
  25  *    may be used to endorse or promote products derived from this software
  26  *    without specific prior written permission.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  29  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  31  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  32  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  33  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  34  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  35  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  36  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  37  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  38  * SUCH DAMAGE.
  39  *
  40  *      From: @(#)bpf_filter.c  8.1 (Berkeley) 6/10/93
  41  *      $Id: bpf_filter.c,v 1.1 1996/04/04 02:45:45 paulus Exp $
  42  */
  43
  44 #include <sys/param.h>
  45 #include <sys/types.h>
  46 #include <sys/stream.h>
  47 #include <net/ppp_defs.h>
  48 #include "ppp_mod.h"
  49
  50 #ifdef SVR4
  51 #ifndef __GNUC__
  52 #include <sys/byteorder.h>      /* for ntohl, etc. */
  53 #else
  54 /* make sure we don't get the gnu "fixed" one! */
  55 #include "/usr/include/sys/byteorder.h"
  56 #endif
  57 #endif
  58
  59 #ifdef OSF1
  60 #include <net/net_globals.h>
  61 #endif
  62 #include <netinet/in.h>
  63
  64 #ifdef AIX4
  65 #define _NETINET_IN_SYSTM_H_
  66 typedef u_long  n_long;
  67 #else
  68 #include <netinet/in_systm.h>
  69 #endif
  70
  71 #if !(defined(__i386__) || defined(__m68k__))   /* any others? */
  72 #define BPF_ALIGN
  73 #endif
  74
  75 #ifndef BPF_ALIGN
  76 #define EXTRACT_SHORT(p)        ((ushort)ntohs(*(ushort *)p))
  77 #define EXTRACT_LONG(p)         (ntohl(*(uint *)p))
  78 #else
  79 #define EXTRACT_SHORT(p)\
  80         ((ushort)\
  81                 ((ushort)*((u_char *)p+0)<<8|\
  82                  (ushort)*((u_char *)p+1)<<0))
  83 #define EXTRACT_LONG(p)\
  84                 ((uint)*((u_char *)p+0)<<24|\
  85                  (uint)*((u_char *)p+1)<<16|\
  86                  (uint)*((u_char *)p+2)<<8|\
  87                  (uint)*((u_char *)p+3)<<0)
  88 #endif
  89
  90 #ifdef _KERNEL
  91 #define MINDEX(len, m, k) \
  92 { \
  93         len = m->b_wptr - m->b_rptr; \
  94         while (k >= len) { \
  95                 k -= len; \
  96                 m = m->b_cont; \
  97                 if (m == 0) \
  98                         return 0; \
  99                 len = m->b_wptr - m->b_rptr; \
 100         } \
 101 }
 102
 103 static int m_xword __P((mblk_t *, int, int *));
 104 static int m_xhalf __P((mblk_t *, int, int *));
 105
 106 static int
 107 m_xword(m, k, err)
 108         register mblk_t *m;
 109         register int k, *err;
 110 {
 111         register int len;
 112         register uchar_t *cp, *np;
 113         register mblk_t *m0;
 114
 115         MINDEX(len, m, k);
 116         cp = m->b_rptr + k;
 117         if (len - k >= 4) {
 118                 *err = 0;
 119                 return EXTRACT_LONG(cp);
 120         }
 121         m0 = m->b_cont;
 122         if (m0 == 0 || m0->b_wptr - m0->b_rptr + len - k < 4)
 123                 goto bad;
 124         *err = 0;
 125         np = m0->b_rptr;
 126         switch (len - k) {
 127
 128         case 1:
 129                 return (cp[0] << 24) | (np[0] << 16) | (np[1] << 8) | np[2];
 130
 131         case 2:
 132                 return (cp[0] << 24) | (cp[1] << 16) | (np[0] << 8) | np[1];
 133
 134         default:
 135                 return (cp[0] << 24) | (cp[1] << 16) | (cp[2] << 8) | np[0];
 136         }
 137     bad:
 138         *err = 1;
 139         return 0;
 140 }
 141
 142 static int
 143 m_xhalf(m, k, err)
 144         register mblk_t *m;
 145         register int k, *err;
 146 {
 147         register int len;
 148         register uchar_t *cp;
 149         register mblk_t *m0;
 150
 151         MINDEX(len, m, k);
 152         cp = m->b_rptr + k;
 153         if (len - k >= 2) {
 154                 *err = 0;
 155                 return EXTRACT_SHORT(cp);
 156         }
 157         m0 = m->b_cont;
 158         if (m0 == 0)
 159                 goto bad;
 160         *err = 0;
 161         return (cp[0] << 8) | m0->b_rptr[0];
 162  bad:
 163         *err = 1;
 164         return 0;
 165 }
 166 #endif
 167
 168 #include <net/bpf.h>
 169
 170 /*
 171  * Execute the filter program starting at pc on the packet p
 172  * wirelen is the length of the original packet
 173  * buflen is the amount of data present
 174  */
 175 uint
 176 bpf_filter(pc, p, wirelen, buflen)
 177         register struct bpf_insn *pc;
 178         register uchar_t *p;
 179         uint wirelen;
 180         register uint buflen;
 181 {
 182         register uint A = 0, X = 0;
 183         register int k;
 184         int mem[BPF_MEMWORDS];
 185
 186         if (pc == 0)
 187                 /*
 188                  * No filter means accept all.
 189                  */
 190                 return (uint)-1;
 191         --pc;
 192         while (1) {
 193                 ++pc;
 194                 switch (pc->code) {
 195
 196                 default:
 197 #ifdef _KERNEL
 198                         return 0;
 199 #else
 200                         abort();
 201 #endif
 202                 case BPF_RET|BPF_K:
 203                         return (uint)pc->k;
 204
 205                 case BPF_RET|BPF_A:
 206                         return (uint)A;
 207
 208                 case BPF_LD|BPF_W|BPF_ABS:
 209                         k = pc->k;
 210                         if (k + sizeof(int) > buflen) {
 211 #ifdef _KERNEL
 212                                 int merr;
 213
 214                                 if (buflen != 0)
 215                                         return 0;
 216                                 A = m_xword((mblk_t *)p, k, &merr);
 217                                 if (merr != 0)
 218                                         return 0;
 219                                 continue;
 220 #else
 221                                 return 0;
 222 #endif
 223                         }
 224                         A = EXTRACT_LONG(&p[k]);
 225                         continue;
 226
 227                 case BPF_LD|BPF_H|BPF_ABS:
 228                         k = pc->k;
 229                         if (k + sizeof(short int) > buflen) {
 230 #ifdef _KERNEL
 231                                 int merr;
 232
 233                                 if (buflen != 0)
 234                                         return 0;
 235                                 A = m_xhalf((mblk_t *)p, k, &merr);
 236                                 continue;
 237 #else
 238                                 return 0;
 239 #endif
 240                         }
 241                         A = EXTRACT_SHORT(&p[k]);
 242                         continue;
 243
 244                 case BPF_LD|BPF_B|BPF_ABS:
 245                         k = pc->k;
 246                         if (k >= buflen) {
 247 #ifdef _KERNEL
 248                                 register mblk_t *m;
 249                                 register int len;
 250
 251                                 if (buflen != 0)
 252                                         return 0;
 253                                 m = (mblk_t *)p;
 254                                 MINDEX(len, m, k);
 255                                 A = m->b_rptr[k];
 256                                 continue;
 257 #else
 258                                 return 0;
 259 #endif
 260                         }
 261                         A = p[k];
 262                         continue;
 263
 264                 case BPF_LD|BPF_W|BPF_LEN:
 265                         A = wirelen;
 266                         continue;
 267
 268                 case BPF_LDX|BPF_W|BPF_LEN:
 269                         X = wirelen;
 270                         continue;
 271
 272                 case BPF_LD|BPF_W|BPF_IND:
 273                         k = X + pc->k;
 274                         if (k + sizeof(int) > buflen) {
 275 #ifdef _KERNEL
 276                                 int merr;
 277
 278                                 if (buflen != 0)
 279                                         return 0;
 280                                 A = m_xword((mblk_t *)p, k, &merr);
 281                                 if (merr != 0)
 282                                         return 0;
 283                                 continue;
 284 #else
 285                                 return 0;
 286 #endif
 287                         }
 288                         A = EXTRACT_LONG(&p[k]);
 289                         continue;
 290
 291                 case BPF_LD|BPF_H|BPF_IND:
 292                         k = X + pc->k;
 293                         if (k + sizeof(short int) > buflen) {
 294 #ifdef _KERNEL
 295                                 int merr;
 296
 297                                 if (buflen != 0)
 298                                         return 0;
 299                                 A = m_xhalf((mblk_t *)p, k, &merr);
 300                                 if (merr != 0)
 301                                         return 0;
 302                                 continue;
 303 #else
 304                                 return 0;
 305 #endif
 306                         }
 307                         A = EXTRACT_SHORT(&p[k]);
 308                         continue;
 309
 310                 case BPF_LD|BPF_B|BPF_IND:
 311                         k = X + pc->k;
 312                         if (k >= buflen) {
 313 #ifdef _KERNEL
 314                                 register mblk_t *m;
 315                                 register int len;
 316
 317                                 if (buflen != 0)
 318                                         return 0;
 319                                 m = (mblk_t *)p;
 320                                 MINDEX(len, m, k);
 321                                 A = m->b_rptr[k];
 322                                 continue;
 323 #else
 324                                 return 0;
 325 #endif
 326                         }
 327                         A = p[k];
 328                         continue;
 329
 330                 case BPF_LDX|BPF_MSH|BPF_B:
 331                         k = pc->k;
 332                         if (k >= buflen) {
 333 #ifdef _KERNEL
 334                                 register mblk_t *m;
 335                                 register int len;
 336
 337                                 if (buflen != 0)
 338                                         return 0;
 339                                 m = (mblk_t *)p;
 340                                 MINDEX(len, m, k);
 341                                 X = (m->b_rptr[k] & 0xf) << 2;
 342                                 continue;
 343 #else
 344                                 return 0;
 345 #endif
 346                         }
 347                         X = (p[pc->k] & 0xf) << 2;
 348                         continue;
 349
 350                 case BPF_LD|BPF_IMM:
 351                         A = pc->k;
 352                         continue;
 353
 354                 case BPF_LDX|BPF_IMM:
 355                         X = pc->k;
 356                         continue;
 357
 358                 case BPF_LD|BPF_MEM:
 359                         A = mem[pc->k];
 360                         continue;
 361
 362                 case BPF_LDX|BPF_MEM:
 363                         X = mem[pc->k];
 364                         continue;
 365
 366                 case BPF_ST:
 367                         mem[pc->k] = A;
 368                         continue;
 369
 370                 case BPF_STX:
 371                         mem[pc->k] = X;
 372                         continue;
 373
 374                 case BPF_JMP|BPF_JA:
 375                         pc += pc->k;
 376                         continue;
 377
 378                 case BPF_JMP|BPF_JGT|BPF_K:
 379                         pc += (A > pc->k) ? pc->jt : pc->jf;
 380                         continue;
 381
 382                 case BPF_JMP|BPF_JGE|BPF_K:
 383                         pc += (A >= pc->k) ? pc->jt : pc->jf;
 384                         continue;
 385
 386                 case BPF_JMP|BPF_JEQ|BPF_K:
 387                         pc += (A == pc->k) ? pc->jt : pc->jf;
 388                         continue;
 389
 390                 case BPF_JMP|BPF_JSET|BPF_K:
 391                         pc += (A & pc->k) ? pc->jt : pc->jf;
 392                         continue;
 393
 394                 case BPF_JMP|BPF_JGT|BPF_X:
 395                         pc += (A > X) ? pc->jt : pc->jf;
 396                         continue;
 397
 398                 case BPF_JMP|BPF_JGE|BPF_X:
 399                         pc += (A >= X) ? pc->jt : pc->jf;
 400                         continue;
 401
 402                 case BPF_JMP|BPF_JEQ|BPF_X:
 403                         pc += (A == X) ? pc->jt : pc->jf;
 404                         continue;
 405
 406                 case BPF_JMP|BPF_JSET|BPF_X:
 407                         pc += (A & X) ? pc->jt : pc->jf;
 408                         continue;
 409
 410                 case BPF_ALU|BPF_ADD|BPF_X:
 411                         A += X;
 412                         continue;
 413
 414                 case BPF_ALU|BPF_SUB|BPF_X:
 415                         A -= X;
 416                         continue;
 417
 418                 case BPF_ALU|BPF_MUL|BPF_X:
 419                         A *= X;
 420                         continue;
 421
 422                 case BPF_ALU|BPF_DIV|BPF_X:
 423                         if (X == 0)
 424                                 return 0;
 425                         A /= X;
 426                         continue;
 427
 428                 case BPF_ALU|BPF_AND|BPF_X:
 429                         A &= X;
 430                         continue;
 431
 432                 case BPF_ALU|BPF_OR|BPF_X:
 433                         A |= X;
 434                         continue;
 435
 436                 case BPF_ALU|BPF_LSH|BPF_X:
 437                         A <<= X;
 438                         continue;
 439
 440                 case BPF_ALU|BPF_RSH|BPF_X:
 441                         A >>= X;
 442                         continue;
 443
 444                 case BPF_ALU|BPF_ADD|BPF_K:
 445                         A += pc->k;
 446                         continue;
 447
 448                 case BPF_ALU|BPF_SUB|BPF_K:
 449                         A -= pc->k;
 450                         continue;
 451
 452                 case BPF_ALU|BPF_MUL|BPF_K:
 453                         A *= pc->k;
 454                         continue;
 455
 456                 case BPF_ALU|BPF_DIV|BPF_K:
 457                         A /= pc->k;
 458                         continue;
 459
 460                 case BPF_ALU|BPF_AND|BPF_K:
 461                         A &= pc->k;
 462                         continue;
 463
 464                 case BPF_ALU|BPF_OR|BPF_K:
 465                         A |= pc->k;
 466                         continue;
 467
 468                 case BPF_ALU|BPF_LSH|BPF_K:
 469                         A <<= pc->k;
 470                         continue;
 471
 472                 case BPF_ALU|BPF_RSH|BPF_K:
 473                         A >>= pc->k;
 474                         continue;
 475
 476                 case BPF_ALU|BPF_NEG:
 477                         A = -A;
 478                         continue;
 479
 480                 case BPF_MISC|BPF_TAX:
 481                         X = A;
 482                         continue;
 483
 484                 case BPF_MISC|BPF_TXA:
 485                         A = X;
 486                         continue;
 487                 }
 488         }
 489 }
 490
 491 #ifdef _KERNEL
 492 /*
 493  * Return true if the 'fcode' is a valid filter program.
 494  * The constraints are that each jump be forward and to a valid
 495  * code.  The code must terminate with either an accept or reject.
 496  * 'valid' is an array for use by the routine (it must be at least
 497  * 'len' bytes long).
 498  *
 499  * The kernel needs to be able to verify an application's filter code.
 500  * Otherwise, a bogus program could easily crash the system.
 501  */
 502 int
 503 bpf_validate(f, len)
 504         struct bpf_insn *f;
 505         int len;
 506 {
 507         register int i;
 508         register struct bpf_insn *p;
 509
 510         for (i = 0; i < len; ++i) {
 511                 /*
 512                  * Check that that jumps are forward, and within
 513                  * the code block.
 514                  */
 515                 p = &f[i];
 516                 if (BPF_CLASS(p->code) == BPF_JMP) {
 517                         register int from = i + 1;
 518
 519                         if (BPF_OP(p->code) == BPF_JA) {
 520                                 if (from + p->k >= len)
 521                                         return 0;
 522                         }
 523                         else if (from + p->jt >= len || from + p->jf >= len)
 524                                 return 0;
 525                 }
 526                 /*
 527                  * Check that memory operations use valid addresses.
 528                  */
 529                 if ((BPF_CLASS(p->code) == BPF_ST ||
 530                      (BPF_CLASS(p->code) == BPF_LD &&
 531                       (p->code & 0xe0) == BPF_MEM)) &&
 532                     (p->k >= BPF_MEMWORDS || p->k < 0))
 533                         return 0;
 534                 /*
 535                  * Check for constant division by 0.
 536                  */
 537                 if (p->code == (BPF_ALU|BPF_DIV|BPF_K) && p->k == 0)
 538                         return 0;
 539         }
 540         return BPF_CLASS(f[len - 1].code) == BPF_RET;
 541 }
 542 #endif