trafgen_lexer.l

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * By Daniel Borkmann <daniel@netsniff-ng.org>
   4  * Copyright 2012 Daniel Borkmann <dborkma@tik.ee.ethz.ch>,
   5  * Swiss federal institute of technology (ETH Zurich)
   6  * Subject to the GPL, version 2.
   7  */
   8
   9 /* lex-func-prefix: yy */
  10
  11 %{
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <ctype.h>
  17 #include <stdbool.h>
  18 #include <arpa/inet.h>
  19
  20 #include "trafgen_parser.tab.h"
  21 #include "xmalloc.h"
  22 #include "built_in.h"
  23 #include "str.h"
  24
  25 extern void yyerror(const char *);
  26
  27 static char *try_convert_shellcode(char *sstr)
  28 {
  29         bool found_any = false;
  30         char *bstr, *ostr = sstr, *hay, *orig = sstr;
  31         size_t j = 0, blen, slen = strlen(sstr), tot = 0;
  32         const char *needle = "\\x";
  33
  34         sstr++;
  35         slen -= 2;
  36
  37         if (slen % 4 != 0)
  38                 return orig;
  39
  40         blen = slen / 4;
  41         hay = sstr;
  42         while ((hay = strstr(hay, needle)) != NULL ) {
  43                 hay += strlen(needle) + 2;
  44                 found_any = true;
  45                 tot++;
  46         }
  47
  48         if (blen != tot || !found_any)
  49                 return orig;
  50
  51         blen += 2;
  52         bstr = xzmalloc(blen);
  53
  54         bstr[j++] = '\"';
  55         while (j < blen - 1)
  56                 bstr[j++] = (uint8_t) strtoul(sstr + 2, &sstr, 16);
  57         bstr[j++] = '\"';
  58
  59         xfree(ostr);
  60         return bstr;
  61 }
  62
  63 %}
  64
  65 %option align
  66 %option nounput
  67 %option noyywrap
  68 %option noreject
  69 %option 8bit
  70 %option caseless
  71 %option noinput
  72 %option nodefault
  73
  74 number_oct      ([0][0-9]+)
  75 number_hex      ([0]?[x][a-fA-F0-9]+)
  76 number_bin      ([0]?[b][0-1]+)
  77 number_dec      (([0])|([1-9][0-9]*))
  78 number_ascii    ([a-zA-Z])
  79
  80 a_hex           ([a-fA-F0-9]+)
  81 mac             ({a_hex}:{a_hex}:{a_hex}:{a_hex}:{a_hex}:{a_hex})
  82 ip4_addr        ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)
  83         /* We're very permissive about IPv6 addresses the grammar accepts, as
  84          * they can come in various different formats. In any case,
  85          * inet_pton(AF_INET6, ...) will reject the invalid ones later on. */
  86 ip6_addr        (({a_hex}?:)?({a_hex}?:)?({a_hex}?:)?({a_hex}?:)?({a_hex}?:)?({a_hex}?:)?({a_hex}?:)?({a_hex})?)
  87
  88 %%
  89
  90 "cpu"           { return K_CPU; }
  91 "fill"          { return K_FILL; }
  92 "rnd"           { return K_RND; }
  93 "csum16"        { return K_CSUMIP; }
  94 "csumip"        { return K_CSUMIP; }
  95 "csumip4"       { return K_CSUMIP; }
  96 "csumicmp"      { return K_CSUMIP; }
  97 "csumicmp4"     { return K_CSUMIP; }
  98 "csumudp"       { return K_CSUMUDP; }
  99 "csumtcp"       { return K_CSUMTCP; }
 100 "csumudp6"      { return K_CSUMUDP6; }
 101 "csumtcp6"      { return K_CSUMTCP6; }
 102 "drnd"          { return K_DRND; }
 103 "dinc"          { return K_DINC; }
 104 "ddec"          { return K_DDEC; }
 105 "seqinc"        { return K_SEQINC; }
 106 "seqdec"        { return K_SEQDEC; }
 107 "const8"|"c8"   { return K_CONST8; }
 108 "const16"|"c16" { return K_CONST16; }
 109 "const32"|"c32" { return K_CONST32; }
 110 "const64"|"c64" { return K_CONST64; }
 111
 112 "prot"[o]?      { return K_PROT; }
 113 "tc"|"tclass"   { return K_TC; }
 114
 115         /* Ethernet */
 116 "daddr"|"da"    { return K_DADDR; }
 117 "saddr"|"sa"    { return K_SADDR; }
 118 "etype"         { return K_ETYPE; }
 119 "type"          { return K_TYPE; }
 120
 121         /* PFC/IEEE 802.3X PAUSE */
 122 "time"          { return K_TIME; }
 123 "pri"|"prio"    { return K_PRIO; }
 124
 125         /* VLAN (802.1Q & 802.1ad) */
 126 "tpid"          { return K_TPID; }
 127 "tci"           { return K_TCI; }
 128 "pcp"           { return K_PCP; }
 129 "dei"|"cfi"     { return K_DEI; }
 130 "1ad"           { return K_1AD; }
 131 "1q"            { return K_1Q; }
 132
 133         /* MPLS (Multi Protocol Label Switching) */
 134 "lbl"|"label"   { return K_LABEL; }
 135 "last"          { return K_LAST; }
 136 "exp"           { return K_EXP; }
 137
 138         /* ARP */
 139 "sha"|"smac"    { return K_SHA; }
 140 "spa"|"sip"     { return K_SPA; }
 141 "tha"|"tmac"    { return K_THA; }
 142 "tpa"|"tip"     { return K_TPA; }
 143 "req"|"request" { return K_REQUEST; }
 144 "reply"         { return K_REPLY; }
 145 "op"|"oper"     { return K_OPER; }
 146 "htype"         { return K_HTYPE; }
 147 "ptype"         { return K_PTYPE; }
 148
 149         /* IPv4 */
 150 "ihl"           { return K_IHL; }
 151 "ver"|"version" { return K_VER; }
 152 "ttl"           { return K_TTL; }
 153 "dscp"          { return K_DSCP; }
 154 "ecn"           { return K_ECN; }
 155 "tos"           { return K_TOS; }
 156 "len"|"length"  { return K_LEN; }
 157 "id"            { return K_ID; }
 158 "flags"         { return K_FLAGS; }
 159 "frag"          { return K_FRAG; }
 160 "csum"          { return K_CSUM; }
 161 "df"            { return K_DF; }
 162 "mf"            { return K_MF; }
 163
 164         /* IPv6 */
 165 "fl"|"flow"     { return K_FLOW; }
 166 "nh"|"nexthdr"  { return K_NEXT_HDR; }
 167 "hl"|"hoplimit" { return K_HOP_LIMIT; }
 168
 169
 170         /* ICMPv4 */
 171 "addr"          { return K_ADDR; }
 172 "mtu"           { return K_MTU; }
 173
 174         /* ICMPv6 */
 175 "code"          { return K_CODE; }
 176 "echorequest"   { return K_ECHO_REQUEST; }
 177 "echoreply"     { return K_ECHO_REPLY; }
 178
 179         /* UDP */
 180 "sp"|"sport"    { return K_SPORT; }
 181 "dp"|"dport"    { return K_DPORT; }
 182
 183         /* TCP */
 184 "seq"           { return K_SEQ; }
 185 "ackseq"|"aseq" { return K_ACK_SEQ; }
 186 "doff"|hlen     { return K_DOFF; }
 187 "cwr"           { return K_CWR; }
 188 "ece"|"ecn"     { return K_ECE; }
 189 "urg"           { return K_URG; }
 190 "ack"           { return K_ACK; }
 191 "psh"           { return K_PSH; }
 192 "rst"           { return K_RST; }
 193 "syn"           { return K_SYN; }
 194 "fin"           { return K_FIN; }
 195 "win"|"window"  { return K_WINDOW; }
 196 "urgptr"        { return K_URG_PTR; }
 197
 198 "eth"           { return K_ETH; }
 199 "pause"         { return K_PAUSE; }
 200 "pfc"           { return K_PFC; }
 201 "vlan"          { return K_VLAN; }
 202 "mpls"          { return K_MPLS; }
 203 "arp"           { return K_ARP; }
 204 "ip4"|"ipv4"    { return K_IP4; }
 205 "ip6"|"ipv6"    { return K_IP6; }
 206 "icmp4"|"icmpv4" { return K_ICMP4; }
 207 "icmp6"|"icmpv6"        { return K_ICMP6; }
 208 "udp"           { return K_UDP; }
 209 "tcp"           { return K_TCP; }
 210
 211 [ ]*"-"[ ]*     { return '-'; }
 212 [ ]*"+"[ ]*     { return '+'; }
 213 [ ]*"*"[ ]*     { return '*'; }
 214 [ ]*"/"[ ]*     { return '/'; }
 215 [ ]*"%"[ ]*     { return '%'; }
 216 [ ]*"&"[ ]*     { return '&'; }
 217 [ ]*"|"[ ]*     { return '|'; }
 218 [ ]*"<"[ ]*     { return '<'; }
 219 [ ]*">"[ ]*     { return '>'; }
 220 [ ]*"^"[ ]*     { return '^'; }
 221 "{"             { return '{'; }
 222 "}"             { return '}'; }
 223 "("             { return '('; }
 224 ")"             { return ')'; }
 225 "["             { return '['; }
 226 "]"             { return ']'; }
 227 ","             { return ','; }
 228 ":"             { return ':'; }
 229 "="             { return '='; }
 230
 231 "\n"            { yylineno++; }
 232
 233 "\""[^\"]+"\""  { yylval.str = try_convert_shellcode(xstrdup(yytext));
 234                   return string; }
 235
 236 ([ \t\n]+)?     { return K_WHITE; }
 237
 238 "/*"([^\*]|\*[^/])*"*/" { return K_COMMENT; }
 239
 240 "#"[^\n]*       { return K_COMMENT; }
 241
 242 {number_hex}    { yylval.number = strtoul(yytext + (yytext[0] == 'x' ? 1 : 0),
 243                                           NULL, 16);
 244                   return number; }
 245
 246 {number_dec}    { yylval.number = strtol(yytext, NULL, 10);
 247                   return number; }
 248
 249 {number_oct}    { yylval.number = strtol(yytext + 1, NULL, 8);
 250                   return number; }
 251
 252 {number_bin}    { yylval.number = strtol(yytext + (yytext[0] == 'b' ? 1 : 2),
 253                                          NULL, 2);
 254                   return number; }
 255
 256 {number_ascii}  { yylval.number = (uint8_t) (*yytext);
 257                   return number; }
 258
 259 {mac}           { if (str2mac(yytext, yylval.bytes, 256))
 260                         panic("Failed to parse MAC address %s\n", yytext);
 261                   return mac; }
 262
 263 {ip4_addr}      { if (inet_pton(AF_INET, yytext, &yylval.ip4_addr) != 1)
 264                         panic("Failed to parse IPv4 address %s\n", yytext);
 265                   return ip4_addr; };
 266
 267 {ip6_addr}      { if (inet_pton(AF_INET6, yytext, &yylval.ip6_addr) != 1)
 268                         panic("Failed to parse IPv6 address %s\n", yytext);
 269                   return ip6_addr; };
 270
 271 "'\\x"[a-fA-F0-9]{2}"'" { yylval.number = strtol(yytext + 3, NULL, 16);
 272                   return number; }
 273
 274 "'"."'"         { yylval.number = (uint8_t) (*(yytext + 1));
 275                   return number; }
 276
 277 ";"[^\n]*       {/* NOP */}
 278 .               { printf("Unknown character '%s'", yytext);
 279                   yyerror("lex Unknown character"); }
 280
 281 %%