Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 1 | /* |
| 2 | * nf_nat_pptp.c |
| 3 | * |
| 4 | * NAT support for PPTP (Point to Point Tunneling Protocol). |
| 5 | * PPTP is a a protocol for creating virtual private networks. |
| 6 | * It is a specification defined by Microsoft and some vendors |
| 7 | * working with Microsoft. PPTP is built on top of a modified |
| 8 | * version of the Internet Generic Routing Encapsulation Protocol. |
| 9 | * GRE is defined in RFC 1701 and RFC 1702. Documentation of |
| 10 | * PPTP can be found in RFC 2637 |
| 11 | * |
| 12 | * (C) 2000-2005 by Harald Welte <laforge@gnumonks.org> |
| 13 | * |
| 14 | * Development of this code funded by Astaro AG (http://www.astaro.com/) |
| 15 | * |
| 16 | * TODO: - NAT to a unique tuple, not to TCP source port |
| 17 | * (needs netfilter tuple reservation) |
| 18 | */ |
| 19 | |
| 20 | #include <linux/module.h> |
| 21 | #include <linux/tcp.h> |
| 22 | |
| 23 | #include <net/netfilter/nf_nat.h> |
| 24 | #include <net/netfilter/nf_nat_helper.h> |
| 25 | #include <net/netfilter/nf_nat_rule.h> |
| 26 | #include <net/netfilter/nf_conntrack_helper.h> |
| 27 | #include <net/netfilter/nf_conntrack_expect.h> |
| 28 | #include <linux/netfilter/nf_conntrack_proto_gre.h> |
| 29 | #include <linux/netfilter/nf_conntrack_pptp.h> |
| 30 | |
| 31 | #define NF_NAT_PPTP_VERSION "3.0" |
| 32 | |
| 33 | #define REQ_CID(req, off) (*(__be16 *)((char *)(req) + (off))) |
| 34 | |
| 35 | MODULE_LICENSE("GPL"); |
| 36 | MODULE_AUTHOR("Harald Welte <laforge@gnumonks.org>"); |
| 37 | MODULE_DESCRIPTION("Netfilter NAT helper module for PPTP"); |
| 38 | MODULE_ALIAS("ip_nat_pptp"); |
| 39 | |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 40 | static void pptp_nat_expected(struct nf_conn *ct, |
| 41 | struct nf_conntrack_expect *exp) |
| 42 | { |
Jan Engelhardt | 9ddd0ed | 2008-01-31 04:51:23 -0800 | [diff] [blame] | 43 | const struct nf_conn *master = ct->master; |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 44 | struct nf_conntrack_expect *other_exp; |
| 45 | struct nf_conntrack_tuple t; |
Jan Engelhardt | 9ddd0ed | 2008-01-31 04:51:23 -0800 | [diff] [blame] | 46 | const struct nf_ct_pptp_master *ct_pptp_info; |
| 47 | const struct nf_nat_pptp *nat_pptp_info; |
Patrick McHardy | 587aa64 | 2007-03-14 16:37:25 -0700 | [diff] [blame] | 48 | struct nf_nat_range range; |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 49 | |
| 50 | ct_pptp_info = &nfct_help(master)->help.ct_pptp_info; |
| 51 | nat_pptp_info = &nfct_nat(master)->help.nat_pptp_info; |
| 52 | |
| 53 | /* And here goes the grand finale of corrosion... */ |
| 54 | if (exp->dir == IP_CT_DIR_ORIGINAL) { |
Patrick McHardy | 0d53778 | 2007-07-07 22:39:38 -0700 | [diff] [blame] | 55 | pr_debug("we are PNS->PAC\n"); |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 56 | /* therefore, build tuple for PAC->PNS */ |
| 57 | t.src.l3num = AF_INET; |
| 58 | t.src.u3.ip = master->tuplehash[!exp->dir].tuple.src.u3.ip; |
| 59 | t.src.u.gre.key = ct_pptp_info->pac_call_id; |
| 60 | t.dst.u3.ip = master->tuplehash[!exp->dir].tuple.dst.u3.ip; |
| 61 | t.dst.u.gre.key = ct_pptp_info->pns_call_id; |
| 62 | t.dst.protonum = IPPROTO_GRE; |
| 63 | } else { |
Patrick McHardy | 0d53778 | 2007-07-07 22:39:38 -0700 | [diff] [blame] | 64 | pr_debug("we are PAC->PNS\n"); |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 65 | /* build tuple for PNS->PAC */ |
| 66 | t.src.l3num = AF_INET; |
Patrick McHardy | a46bf7d | 2007-01-26 01:07:30 -0800 | [diff] [blame] | 67 | t.src.u3.ip = master->tuplehash[!exp->dir].tuple.src.u3.ip; |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 68 | t.src.u.gre.key = nat_pptp_info->pns_call_id; |
Patrick McHardy | a46bf7d | 2007-01-26 01:07:30 -0800 | [diff] [blame] | 69 | t.dst.u3.ip = master->tuplehash[!exp->dir].tuple.dst.u3.ip; |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 70 | t.dst.u.gre.key = nat_pptp_info->pac_call_id; |
| 71 | t.dst.protonum = IPPROTO_GRE; |
| 72 | } |
| 73 | |
Patrick McHardy | 0d53778 | 2007-07-07 22:39:38 -0700 | [diff] [blame] | 74 | pr_debug("trying to unexpect other dir: "); |
Jan Engelhardt | 3c9fba6 | 2008-04-14 11:15:54 +0200 | [diff] [blame] | 75 | nf_ct_dump_tuple_ip(&t); |
Patrick McHardy | 6823645 | 2007-07-07 22:30:49 -0700 | [diff] [blame] | 76 | other_exp = nf_ct_expect_find_get(&t); |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 77 | if (other_exp) { |
Patrick McHardy | 6823645 | 2007-07-07 22:30:49 -0700 | [diff] [blame] | 78 | nf_ct_unexpect_related(other_exp); |
| 79 | nf_ct_expect_put(other_exp); |
Patrick McHardy | 0d53778 | 2007-07-07 22:39:38 -0700 | [diff] [blame] | 80 | pr_debug("success\n"); |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 81 | } else { |
Patrick McHardy | 0d53778 | 2007-07-07 22:39:38 -0700 | [diff] [blame] | 82 | pr_debug("not found!\n"); |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 83 | } |
| 84 | |
| 85 | /* This must be a fresh one. */ |
| 86 | BUG_ON(ct->status & IPS_NAT_DONE_MASK); |
| 87 | |
| 88 | /* Change src to where master sends to */ |
| 89 | range.flags = IP_NAT_RANGE_MAP_IPS; |
| 90 | range.min_ip = range.max_ip |
| 91 | = ct->master->tuplehash[!exp->dir].tuple.dst.u3.ip; |
| 92 | if (exp->dir == IP_CT_DIR_ORIGINAL) { |
| 93 | range.flags |= IP_NAT_RANGE_PROTO_SPECIFIED; |
| 94 | range.min = range.max = exp->saved_proto; |
| 95 | } |
Patrick McHardy | cc01dcb | 2007-12-17 22:38:20 -0800 | [diff] [blame] | 96 | nf_nat_setup_info(ct, &range, IP_NAT_MANIP_SRC); |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 97 | |
| 98 | /* For DST manip, map port here to where it's expected. */ |
| 99 | range.flags = IP_NAT_RANGE_MAP_IPS; |
| 100 | range.min_ip = range.max_ip |
| 101 | = ct->master->tuplehash[!exp->dir].tuple.src.u3.ip; |
| 102 | if (exp->dir == IP_CT_DIR_REPLY) { |
| 103 | range.flags |= IP_NAT_RANGE_PROTO_SPECIFIED; |
| 104 | range.min = range.max = exp->saved_proto; |
| 105 | } |
Patrick McHardy | cc01dcb | 2007-12-17 22:38:20 -0800 | [diff] [blame] | 106 | nf_nat_setup_info(ct, &range, IP_NAT_MANIP_DST); |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 107 | } |
| 108 | |
| 109 | /* outbound packets == from PNS to PAC */ |
| 110 | static int |
Herbert Xu | 3db05fe | 2007-10-15 00:53:15 -0700 | [diff] [blame] | 111 | pptp_outbound_pkt(struct sk_buff *skb, |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 112 | struct nf_conn *ct, |
| 113 | enum ip_conntrack_info ctinfo, |
| 114 | struct PptpControlHeader *ctlh, |
| 115 | union pptp_ctrl_union *pptpReq) |
| 116 | |
| 117 | { |
| 118 | struct nf_ct_pptp_master *ct_pptp_info; |
| 119 | struct nf_nat_pptp *nat_pptp_info; |
| 120 | u_int16_t msg; |
| 121 | __be16 new_callid; |
| 122 | unsigned int cid_off; |
| 123 | |
| 124 | ct_pptp_info = &nfct_help(ct)->help.ct_pptp_info; |
| 125 | nat_pptp_info = &nfct_nat(ct)->help.nat_pptp_info; |
| 126 | |
| 127 | new_callid = ct_pptp_info->pns_call_id; |
| 128 | |
| 129 | switch (msg = ntohs(ctlh->messageType)) { |
| 130 | case PPTP_OUT_CALL_REQUEST: |
| 131 | cid_off = offsetof(union pptp_ctrl_union, ocreq.callID); |
| 132 | /* FIXME: ideally we would want to reserve a call ID |
| 133 | * here. current netfilter NAT core is not able to do |
| 134 | * this :( For now we use TCP source port. This breaks |
| 135 | * multiple calls within one control session */ |
| 136 | |
| 137 | /* save original call ID in nat_info */ |
| 138 | nat_pptp_info->pns_call_id = ct_pptp_info->pns_call_id; |
| 139 | |
| 140 | /* don't use tcph->source since we are at a DSTmanip |
| 141 | * hook (e.g. PREROUTING) and pkt is not mangled yet */ |
| 142 | new_callid = ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u.tcp.port; |
| 143 | |
| 144 | /* save new call ID in ct info */ |
| 145 | ct_pptp_info->pns_call_id = new_callid; |
| 146 | break; |
| 147 | case PPTP_IN_CALL_REPLY: |
| 148 | cid_off = offsetof(union pptp_ctrl_union, icack.callID); |
| 149 | break; |
| 150 | case PPTP_CALL_CLEAR_REQUEST: |
| 151 | cid_off = offsetof(union pptp_ctrl_union, clrreq.callID); |
| 152 | break; |
| 153 | default: |
Patrick McHardy | 0d53778 | 2007-07-07 22:39:38 -0700 | [diff] [blame] | 154 | pr_debug("unknown outbound packet 0x%04x:%s\n", msg, |
| 155 | msg <= PPTP_MSG_MAX ? pptp_msg_name[msg] : |
| 156 | pptp_msg_name[0]); |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 157 | /* fall through */ |
| 158 | case PPTP_SET_LINK_INFO: |
| 159 | /* only need to NAT in case PAC is behind NAT box */ |
| 160 | case PPTP_START_SESSION_REQUEST: |
| 161 | case PPTP_START_SESSION_REPLY: |
| 162 | case PPTP_STOP_SESSION_REQUEST: |
| 163 | case PPTP_STOP_SESSION_REPLY: |
| 164 | case PPTP_ECHO_REQUEST: |
| 165 | case PPTP_ECHO_REPLY: |
| 166 | /* no need to alter packet */ |
| 167 | return NF_ACCEPT; |
| 168 | } |
| 169 | |
| 170 | /* only OUT_CALL_REQUEST, IN_CALL_REPLY, CALL_CLEAR_REQUEST pass |
| 171 | * down to here */ |
Patrick McHardy | 0d53778 | 2007-07-07 22:39:38 -0700 | [diff] [blame] | 172 | pr_debug("altering call id from 0x%04x to 0x%04x\n", |
| 173 | ntohs(REQ_CID(pptpReq, cid_off)), ntohs(new_callid)); |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 174 | |
| 175 | /* mangle packet */ |
Herbert Xu | 3db05fe | 2007-10-15 00:53:15 -0700 | [diff] [blame] | 176 | if (nf_nat_mangle_tcp_packet(skb, ct, ctinfo, |
YOSHIFUJI Hideaki | e905a9e | 2007-02-09 23:24:47 +0900 | [diff] [blame] | 177 | cid_off + sizeof(struct pptp_pkt_hdr) + |
| 178 | sizeof(struct PptpControlHeader), |
| 179 | sizeof(new_callid), (char *)&new_callid, |
| 180 | sizeof(new_callid)) == 0) |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 181 | return NF_DROP; |
| 182 | return NF_ACCEPT; |
| 183 | } |
| 184 | |
| 185 | static void |
| 186 | pptp_exp_gre(struct nf_conntrack_expect *expect_orig, |
| 187 | struct nf_conntrack_expect *expect_reply) |
| 188 | { |
Jan Engelhardt | 9ddd0ed | 2008-01-31 04:51:23 -0800 | [diff] [blame] | 189 | const struct nf_conn *ct = expect_orig->master; |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 190 | struct nf_ct_pptp_master *ct_pptp_info; |
| 191 | struct nf_nat_pptp *nat_pptp_info; |
| 192 | |
| 193 | ct_pptp_info = &nfct_help(ct)->help.ct_pptp_info; |
| 194 | nat_pptp_info = &nfct_nat(ct)->help.nat_pptp_info; |
| 195 | |
| 196 | /* save original PAC call ID in nat_info */ |
| 197 | nat_pptp_info->pac_call_id = ct_pptp_info->pac_call_id; |
| 198 | |
| 199 | /* alter expectation for PNS->PAC direction */ |
| 200 | expect_orig->saved_proto.gre.key = ct_pptp_info->pns_call_id; |
| 201 | expect_orig->tuple.src.u.gre.key = nat_pptp_info->pns_call_id; |
| 202 | expect_orig->tuple.dst.u.gre.key = ct_pptp_info->pac_call_id; |
| 203 | expect_orig->dir = IP_CT_DIR_ORIGINAL; |
| 204 | |
| 205 | /* alter expectation for PAC->PNS direction */ |
| 206 | expect_reply->saved_proto.gre.key = nat_pptp_info->pns_call_id; |
| 207 | expect_reply->tuple.src.u.gre.key = nat_pptp_info->pac_call_id; |
| 208 | expect_reply->tuple.dst.u.gre.key = ct_pptp_info->pns_call_id; |
| 209 | expect_reply->dir = IP_CT_DIR_REPLY; |
| 210 | } |
| 211 | |
| 212 | /* inbound packets == from PAC to PNS */ |
| 213 | static int |
Herbert Xu | 3db05fe | 2007-10-15 00:53:15 -0700 | [diff] [blame] | 214 | pptp_inbound_pkt(struct sk_buff *skb, |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 215 | struct nf_conn *ct, |
| 216 | enum ip_conntrack_info ctinfo, |
| 217 | struct PptpControlHeader *ctlh, |
| 218 | union pptp_ctrl_union *pptpReq) |
| 219 | { |
Jan Engelhardt | 9ddd0ed | 2008-01-31 04:51:23 -0800 | [diff] [blame] | 220 | const struct nf_nat_pptp *nat_pptp_info; |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 221 | u_int16_t msg; |
| 222 | __be16 new_pcid; |
| 223 | unsigned int pcid_off; |
| 224 | |
| 225 | nat_pptp_info = &nfct_nat(ct)->help.nat_pptp_info; |
| 226 | new_pcid = nat_pptp_info->pns_call_id; |
| 227 | |
| 228 | switch (msg = ntohs(ctlh->messageType)) { |
| 229 | case PPTP_OUT_CALL_REPLY: |
| 230 | pcid_off = offsetof(union pptp_ctrl_union, ocack.peersCallID); |
| 231 | break; |
| 232 | case PPTP_IN_CALL_CONNECT: |
| 233 | pcid_off = offsetof(union pptp_ctrl_union, iccon.peersCallID); |
| 234 | break; |
| 235 | case PPTP_IN_CALL_REQUEST: |
| 236 | /* only need to nat in case PAC is behind NAT box */ |
| 237 | return NF_ACCEPT; |
| 238 | case PPTP_WAN_ERROR_NOTIFY: |
| 239 | pcid_off = offsetof(union pptp_ctrl_union, wanerr.peersCallID); |
| 240 | break; |
| 241 | case PPTP_CALL_DISCONNECT_NOTIFY: |
| 242 | pcid_off = offsetof(union pptp_ctrl_union, disc.callID); |
| 243 | break; |
| 244 | case PPTP_SET_LINK_INFO: |
| 245 | pcid_off = offsetof(union pptp_ctrl_union, setlink.peersCallID); |
| 246 | break; |
| 247 | default: |
Patrick McHardy | 0d53778 | 2007-07-07 22:39:38 -0700 | [diff] [blame] | 248 | pr_debug("unknown inbound packet %s\n", |
| 249 | msg <= PPTP_MSG_MAX ? pptp_msg_name[msg] : |
| 250 | pptp_msg_name[0]); |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 251 | /* fall through */ |
| 252 | case PPTP_START_SESSION_REQUEST: |
| 253 | case PPTP_START_SESSION_REPLY: |
| 254 | case PPTP_STOP_SESSION_REQUEST: |
| 255 | case PPTP_STOP_SESSION_REPLY: |
| 256 | case PPTP_ECHO_REQUEST: |
| 257 | case PPTP_ECHO_REPLY: |
| 258 | /* no need to alter packet */ |
| 259 | return NF_ACCEPT; |
| 260 | } |
| 261 | |
| 262 | /* only OUT_CALL_REPLY, IN_CALL_CONNECT, IN_CALL_REQUEST, |
| 263 | * WAN_ERROR_NOTIFY, CALL_DISCONNECT_NOTIFY pass down here */ |
| 264 | |
| 265 | /* mangle packet */ |
Patrick McHardy | 0d53778 | 2007-07-07 22:39:38 -0700 | [diff] [blame] | 266 | pr_debug("altering peer call id from 0x%04x to 0x%04x\n", |
| 267 | ntohs(REQ_CID(pptpReq, pcid_off)), ntohs(new_pcid)); |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 268 | |
Herbert Xu | 3db05fe | 2007-10-15 00:53:15 -0700 | [diff] [blame] | 269 | if (nf_nat_mangle_tcp_packet(skb, ct, ctinfo, |
YOSHIFUJI Hideaki | e905a9e | 2007-02-09 23:24:47 +0900 | [diff] [blame] | 270 | pcid_off + sizeof(struct pptp_pkt_hdr) + |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 271 | sizeof(struct PptpControlHeader), |
| 272 | sizeof(new_pcid), (char *)&new_pcid, |
| 273 | sizeof(new_pcid)) == 0) |
| 274 | return NF_DROP; |
| 275 | return NF_ACCEPT; |
| 276 | } |
| 277 | |
| 278 | static int __init nf_nat_helper_pptp_init(void) |
| 279 | { |
| 280 | nf_nat_need_gre(); |
| 281 | |
Patrick McHardy | d1332e0 | 2007-11-05 20:43:30 -0800 | [diff] [blame] | 282 | BUG_ON(nf_nat_pptp_hook_outbound != NULL); |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 283 | rcu_assign_pointer(nf_nat_pptp_hook_outbound, pptp_outbound_pkt); |
| 284 | |
Patrick McHardy | d1332e0 | 2007-11-05 20:43:30 -0800 | [diff] [blame] | 285 | BUG_ON(nf_nat_pptp_hook_inbound != NULL); |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 286 | rcu_assign_pointer(nf_nat_pptp_hook_inbound, pptp_inbound_pkt); |
| 287 | |
Patrick McHardy | d1332e0 | 2007-11-05 20:43:30 -0800 | [diff] [blame] | 288 | BUG_ON(nf_nat_pptp_hook_exp_gre != NULL); |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 289 | rcu_assign_pointer(nf_nat_pptp_hook_exp_gre, pptp_exp_gre); |
| 290 | |
Patrick McHardy | d1332e0 | 2007-11-05 20:43:30 -0800 | [diff] [blame] | 291 | BUG_ON(nf_nat_pptp_hook_expectfn != NULL); |
Patrick McHardy | f09943f | 2006-12-02 22:09:41 -0800 | [diff] [blame] | 292 | rcu_assign_pointer(nf_nat_pptp_hook_expectfn, pptp_nat_expected); |
| 293 | return 0; |
| 294 | } |
| 295 | |
| 296 | static void __exit nf_nat_helper_pptp_fini(void) |
| 297 | { |
| 298 | rcu_assign_pointer(nf_nat_pptp_hook_expectfn, NULL); |
| 299 | rcu_assign_pointer(nf_nat_pptp_hook_exp_gre, NULL); |
| 300 | rcu_assign_pointer(nf_nat_pptp_hook_inbound, NULL); |
| 301 | rcu_assign_pointer(nf_nat_pptp_hook_outbound, NULL); |
| 302 | synchronize_rcu(); |
| 303 | } |
| 304 | |
| 305 | module_init(nf_nat_helper_pptp_init); |
| 306 | module_exit(nf_nat_helper_pptp_fini); |