/proc/self/cwd/external/curl/lib/socks.c
Line | Count | Source (jump to first uncovered line) |
1 | | /*************************************************************************** |
2 | | * _ _ ____ _ |
3 | | * Project ___| | | | _ \| | |
4 | | * / __| | | | |_) | | |
5 | | * | (__| |_| | _ <| |___ |
6 | | * \___|\___/|_| \_\_____| |
7 | | * |
8 | | * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al. |
9 | | * |
10 | | * This software is licensed as described in the file COPYING, which |
11 | | * you should have received as part of this distribution. The terms |
12 | | * are also available at https://curl.se/docs/copyright.html. |
13 | | * |
14 | | * You may opt to use, copy, modify, merge, publish, distribute and/or sell |
15 | | * copies of the Software, and permit persons to whom the Software is |
16 | | * furnished to do so, under the terms of the COPYING file. |
17 | | * |
18 | | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY |
19 | | * KIND, either express or implied. |
20 | | * |
21 | | * SPDX-License-Identifier: curl |
22 | | * |
23 | | ***************************************************************************/ |
24 | | |
25 | | #include "curl_setup.h" |
26 | | |
27 | | #if !defined(CURL_DISABLE_PROXY) |
28 | | |
29 | | #ifdef HAVE_NETINET_IN_H |
30 | | #include <netinet/in.h> |
31 | | #endif |
32 | | #ifdef HAVE_ARPA_INET_H |
33 | | #include <arpa/inet.h> |
34 | | #endif |
35 | | |
36 | | #include "urldata.h" |
37 | | #include "sendf.h" |
38 | | #include "select.h" |
39 | | #include "cfilters.h" |
40 | | #include "connect.h" |
41 | | #include "timeval.h" |
42 | | #include "socks.h" |
43 | | #include "multiif.h" /* for getsock macros */ |
44 | | #include "inet_pton.h" |
45 | | #include "url.h" |
46 | | |
47 | | /* The last 3 #include files should be in this order */ |
48 | | #include "curl_printf.h" |
49 | | #include "curl_memory.h" |
50 | | #include "memdebug.h" |
51 | | |
52 | | /* for the (SOCKS) connect state machine */ |
53 | | enum connect_t { |
54 | | CONNECT_INIT, |
55 | | CONNECT_SOCKS_INIT, /* 1 */ |
56 | | CONNECT_SOCKS_SEND, /* 2 waiting to send more first data */ |
57 | | CONNECT_SOCKS_READ_INIT, /* 3 set up read */ |
58 | | CONNECT_SOCKS_READ, /* 4 read server response */ |
59 | | CONNECT_GSSAPI_INIT, /* 5 */ |
60 | | CONNECT_AUTH_INIT, /* 6 setup outgoing auth buffer */ |
61 | | CONNECT_AUTH_SEND, /* 7 send auth */ |
62 | | CONNECT_AUTH_READ, /* 8 read auth response */ |
63 | | CONNECT_REQ_INIT, /* 9 init SOCKS "request" */ |
64 | | CONNECT_RESOLVING, /* 10 */ |
65 | | CONNECT_RESOLVED, /* 11 */ |
66 | | CONNECT_RESOLVE_REMOTE, /* 12 */ |
67 | | CONNECT_REQ_SEND, /* 13 */ |
68 | | CONNECT_REQ_SENDING, /* 14 */ |
69 | | CONNECT_REQ_READ, /* 15 */ |
70 | | CONNECT_REQ_READ_MORE, /* 16 */ |
71 | | CONNECT_DONE /* 17 connected fine to the remote or the SOCKS proxy */ |
72 | | }; |
73 | | |
74 | | struct socks_state { |
75 | | enum connect_t state; |
76 | | ssize_t outstanding; /* send this many bytes more */ |
77 | | unsigned char *outp; /* send from this pointer */ |
78 | | |
79 | | const char *hostname; |
80 | | int remote_port; |
81 | | const char *proxy_user; |
82 | | const char *proxy_password; |
83 | | }; |
84 | | |
85 | | #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
86 | | /* |
87 | | * Helper read-from-socket functions. Does the same as Curl_read() but it |
88 | | * blocks until all bytes amount of buffersize will be read. No more, no less. |
89 | | * |
90 | | * This is STUPID BLOCKING behavior. Only used by the SOCKS GSSAPI functions. |
91 | | */ |
92 | | int Curl_blockread_all(struct Curl_cfilter *cf, |
93 | | struct Curl_easy *data, /* transfer */ |
94 | | char *buf, /* store read data here */ |
95 | | ssize_t buffersize, /* max amount to read */ |
96 | | ssize_t *n) /* amount bytes read */ |
97 | | { |
98 | | ssize_t nread = 0; |
99 | | ssize_t allread = 0; |
100 | | int result; |
101 | | CURLcode err = CURLE_OK; |
102 | | |
103 | | *n = 0; |
104 | | for(;;) { |
105 | | timediff_t timeout_ms = Curl_timeleft(data, NULL, TRUE); |
106 | | if(timeout_ms < 0) { |
107 | | /* we already got the timeout */ |
108 | | result = CURLE_OPERATION_TIMEDOUT; |
109 | | break; |
110 | | } |
111 | | if(!timeout_ms) |
112 | | timeout_ms = TIMEDIFF_T_MAX; |
113 | | if(SOCKET_READABLE(cf->conn->sock[cf->sockindex], timeout_ms) <= 0) { |
114 | | result = ~CURLE_OK; |
115 | | break; |
116 | | } |
117 | | nread = Curl_conn_cf_recv(cf->next, data, buf, buffersize, &err); |
118 | | if(nread <= 0) { |
119 | | result = err; |
120 | | if(CURLE_AGAIN == err) |
121 | | continue; |
122 | | if(err) { |
123 | | break; |
124 | | } |
125 | | } |
126 | | |
127 | | if(buffersize == nread) { |
128 | | allread += nread; |
129 | | *n = allread; |
130 | | result = CURLE_OK; |
131 | | break; |
132 | | } |
133 | | if(!nread) { |
134 | | result = ~CURLE_OK; |
135 | | break; |
136 | | } |
137 | | |
138 | | buffersize -= nread; |
139 | | buf += nread; |
140 | | allread += nread; |
141 | | } |
142 | | return result; |
143 | | } |
144 | | #endif |
145 | | |
146 | | #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS) |
147 | | #define DEBUG_AND_VERBOSE |
148 | | #define sxstate(x,d,y) socksstate(x,d,y, __LINE__) |
149 | | #else |
150 | 0 | #define sxstate(x,d,y) socksstate(x,d,y) |
151 | | #endif |
152 | | |
153 | | /* always use this function to change state, to make debugging easier */ |
154 | | static void socksstate(struct socks_state *sx, struct Curl_easy *data, |
155 | | enum connect_t state |
156 | | #ifdef DEBUG_AND_VERBOSE |
157 | | , int lineno |
158 | | #endif |
159 | | ) |
160 | 0 | { |
161 | 0 | enum connect_t oldstate = sx->state; |
162 | | #ifdef DEBUG_AND_VERBOSE |
163 | | /* synced with the state list in urldata.h */ |
164 | | static const char * const socks_statename[] = { |
165 | | "INIT", |
166 | | "SOCKS_INIT", |
167 | | "SOCKS_SEND", |
168 | | "SOCKS_READ_INIT", |
169 | | "SOCKS_READ", |
170 | | "GSSAPI_INIT", |
171 | | "AUTH_INIT", |
172 | | "AUTH_SEND", |
173 | | "AUTH_READ", |
174 | | "REQ_INIT", |
175 | | "RESOLVING", |
176 | | "RESOLVED", |
177 | | "RESOLVE_REMOTE", |
178 | | "REQ_SEND", |
179 | | "REQ_SENDING", |
180 | | "REQ_READ", |
181 | | "REQ_READ_MORE", |
182 | | "DONE" |
183 | | }; |
184 | | #endif |
185 | |
|
186 | 0 | (void)data; |
187 | 0 | if(oldstate == state) |
188 | | /* don't bother when the new state is the same as the old state */ |
189 | 0 | return; |
190 | | |
191 | 0 | sx->state = state; |
192 | |
|
193 | | #ifdef DEBUG_AND_VERBOSE |
194 | | infof(data, |
195 | | "SXSTATE: %s => %s; line %d", |
196 | | socks_statename[oldstate], socks_statename[sx->state], |
197 | | lineno); |
198 | | #endif |
199 | 0 | } |
200 | | |
201 | | static CURLproxycode socks_state_send(struct Curl_cfilter *cf, |
202 | | struct socks_state *sx, |
203 | | struct Curl_easy *data, |
204 | | CURLproxycode failcode, |
205 | | const char *description) |
206 | 0 | { |
207 | 0 | ssize_t nwritten; |
208 | 0 | CURLcode result; |
209 | |
|
210 | 0 | nwritten = Curl_conn_cf_send(cf->next, data, (char *)sx->outp, |
211 | 0 | sx->outstanding, &result); |
212 | 0 | if(nwritten <= 0) { |
213 | 0 | if(CURLE_AGAIN == result) { |
214 | 0 | return CURLPX_OK; |
215 | 0 | } |
216 | 0 | else if(CURLE_OK == result) { |
217 | | /* connection closed */ |
218 | 0 | failf(data, "connection to proxy closed"); |
219 | 0 | return CURLPX_CLOSED; |
220 | 0 | } |
221 | 0 | failf(data, "Failed to send %s: %s", description, |
222 | 0 | curl_easy_strerror(result)); |
223 | 0 | return failcode; |
224 | 0 | } |
225 | 0 | DEBUGASSERT(sx->outstanding >= nwritten); |
226 | | /* not done, remain in state */ |
227 | 0 | sx->outstanding -= nwritten; |
228 | 0 | sx->outp += nwritten; |
229 | 0 | return CURLPX_OK; |
230 | 0 | } |
231 | | |
232 | | static CURLproxycode socks_state_recv(struct Curl_cfilter *cf, |
233 | | struct socks_state *sx, |
234 | | struct Curl_easy *data, |
235 | | CURLproxycode failcode, |
236 | | const char *description) |
237 | 0 | { |
238 | 0 | ssize_t nread; |
239 | 0 | CURLcode result; |
240 | |
|
241 | 0 | nread = Curl_conn_cf_recv(cf->next, data, (char *)sx->outp, |
242 | 0 | sx->outstanding, &result); |
243 | 0 | if(nread <= 0) { |
244 | 0 | if(CURLE_AGAIN == result) { |
245 | 0 | return CURLPX_OK; |
246 | 0 | } |
247 | 0 | else if(CURLE_OK == result) { |
248 | | /* connection closed */ |
249 | 0 | failf(data, "connection to proxy closed"); |
250 | 0 | return CURLPX_CLOSED; |
251 | 0 | } |
252 | 0 | failf(data, "SOCKS4: Failed receiving %s: %s", description, |
253 | 0 | curl_easy_strerror(result)); |
254 | 0 | return failcode; |
255 | 0 | } |
256 | | /* remain in reading state */ |
257 | 0 | DEBUGASSERT(sx->outstanding >= nread); |
258 | 0 | sx->outstanding -= nread; |
259 | 0 | sx->outp += nread; |
260 | 0 | return CURLPX_OK; |
261 | 0 | } |
262 | | |
263 | | /* |
264 | | * This function logs in to a SOCKS4 proxy and sends the specifics to the final |
265 | | * destination server. |
266 | | * |
267 | | * Reference : |
268 | | * https://www.openssh.com/txt/socks4.protocol |
269 | | * |
270 | | * Note : |
271 | | * Set protocol4a=true for "SOCKS 4A (Simple Extension to SOCKS 4 Protocol)" |
272 | | * Nonsupport "Identification Protocol (RFC1413)" |
273 | | */ |
274 | | static CURLproxycode do_SOCKS4(struct Curl_cfilter *cf, |
275 | | struct socks_state *sx, |
276 | | struct Curl_easy *data) |
277 | 0 | { |
278 | 0 | struct connectdata *conn = cf->conn; |
279 | 0 | const bool protocol4a = |
280 | 0 | (conn->socks_proxy.proxytype == CURLPROXY_SOCKS4A) ? TRUE : FALSE; |
281 | 0 | unsigned char *socksreq = (unsigned char *)data->state.buffer; |
282 | 0 | CURLcode result; |
283 | 0 | CURLproxycode presult; |
284 | 0 | struct Curl_dns_entry *dns = NULL; |
285 | | |
286 | | /* make sure that the buffer is at least 600 bytes */ |
287 | 0 | DEBUGASSERT(READBUFFER_MIN >= 600); |
288 | |
|
289 | 0 | switch(sx->state) { |
290 | 0 | case CONNECT_SOCKS_INIT: |
291 | | /* SOCKS4 can only do IPv4, insist! */ |
292 | 0 | conn->ip_version = CURL_IPRESOLVE_V4; |
293 | 0 | if(conn->bits.httpproxy) |
294 | 0 | infof(data, "SOCKS4%s: connecting to HTTP proxy %s port %d", |
295 | 0 | protocol4a ? "a" : "", sx->hostname, sx->remote_port); |
296 | |
|
297 | 0 | infof(data, "SOCKS4 communication to %s:%d", |
298 | 0 | sx->hostname, sx->remote_port); |
299 | | |
300 | | /* |
301 | | * Compose socks4 request |
302 | | * |
303 | | * Request format |
304 | | * |
305 | | * +----+----+----+----+----+----+----+----+----+----+....+----+ |
306 | | * | VN | CD | DSTPORT | DSTIP | USERID |NULL| |
307 | | * +----+----+----+----+----+----+----+----+----+----+....+----+ |
308 | | * # of bytes: 1 1 2 4 variable 1 |
309 | | */ |
310 | |
|
311 | 0 | socksreq[0] = 4; /* version (SOCKS4) */ |
312 | 0 | socksreq[1] = 1; /* connect */ |
313 | 0 | socksreq[2] = (unsigned char)((sx->remote_port >> 8) & 0xff); /* MSB */ |
314 | 0 | socksreq[3] = (unsigned char)(sx->remote_port & 0xff); /* LSB */ |
315 | | |
316 | | /* DNS resolve only for SOCKS4, not SOCKS4a */ |
317 | 0 | if(!protocol4a) { |
318 | 0 | enum resolve_t rc = |
319 | 0 | Curl_resolv(data, sx->hostname, sx->remote_port, TRUE, &dns); |
320 | |
|
321 | 0 | if(rc == CURLRESOLV_ERROR) |
322 | 0 | return CURLPX_RESOLVE_HOST; |
323 | 0 | else if(rc == CURLRESOLV_PENDING) { |
324 | 0 | sxstate(sx, data, CONNECT_RESOLVING); |
325 | 0 | infof(data, "SOCKS4 non-blocking resolve of %s", sx->hostname); |
326 | 0 | return CURLPX_OK; |
327 | 0 | } |
328 | 0 | sxstate(sx, data, CONNECT_RESOLVED); |
329 | 0 | goto CONNECT_RESOLVED; |
330 | 0 | } |
331 | | |
332 | | /* socks4a doesn't resolve anything locally */ |
333 | 0 | sxstate(sx, data, CONNECT_REQ_INIT); |
334 | 0 | goto CONNECT_REQ_INIT; |
335 | | |
336 | 0 | case CONNECT_RESOLVING: |
337 | | /* check if we have the name resolved by now */ |
338 | 0 | dns = Curl_fetch_addr(data, sx->hostname, (int)conn->port); |
339 | |
|
340 | 0 | if(dns) { |
341 | | #ifdef CURLRES_ASYNCH |
342 | | data->state.async.dns = dns; |
343 | | data->state.async.done = TRUE; |
344 | | #endif |
345 | 0 | infof(data, "Hostname '%s' was found", sx->hostname); |
346 | 0 | sxstate(sx, data, CONNECT_RESOLVED); |
347 | 0 | } |
348 | 0 | else { |
349 | 0 | result = Curl_resolv_check(data, &dns); |
350 | 0 | if(!dns) { |
351 | 0 | if(result) |
352 | 0 | return CURLPX_RESOLVE_HOST; |
353 | 0 | return CURLPX_OK; |
354 | 0 | } |
355 | 0 | } |
356 | | /* FALLTHROUGH */ |
357 | 0 | CONNECT_RESOLVED: |
358 | 0 | case CONNECT_RESOLVED: { |
359 | 0 | struct Curl_addrinfo *hp = NULL; |
360 | | /* |
361 | | * We cannot use 'hostent' as a struct that Curl_resolv() returns. It |
362 | | * returns a Curl_addrinfo pointer that may not always look the same. |
363 | | */ |
364 | 0 | if(dns) { |
365 | 0 | hp = dns->addr; |
366 | | |
367 | | /* scan for the first IPv4 address */ |
368 | 0 | while(hp && (hp->ai_family != AF_INET)) |
369 | 0 | hp = hp->ai_next; |
370 | |
|
371 | 0 | if(hp) { |
372 | 0 | struct sockaddr_in *saddr_in; |
373 | 0 | char buf[64]; |
374 | 0 | Curl_printable_address(hp, buf, sizeof(buf)); |
375 | |
|
376 | 0 | saddr_in = (struct sockaddr_in *)(void *)hp->ai_addr; |
377 | 0 | socksreq[4] = ((unsigned char *)&saddr_in->sin_addr.s_addr)[0]; |
378 | 0 | socksreq[5] = ((unsigned char *)&saddr_in->sin_addr.s_addr)[1]; |
379 | 0 | socksreq[6] = ((unsigned char *)&saddr_in->sin_addr.s_addr)[2]; |
380 | 0 | socksreq[7] = ((unsigned char *)&saddr_in->sin_addr.s_addr)[3]; |
381 | |
|
382 | 0 | infof(data, "SOCKS4 connect to IPv4 %s (locally resolved)", buf); |
383 | |
|
384 | 0 | Curl_resolv_unlock(data, dns); /* not used anymore from now on */ |
385 | 0 | } |
386 | 0 | else |
387 | 0 | failf(data, "SOCKS4 connection to %s not supported", sx->hostname); |
388 | 0 | } |
389 | 0 | else |
390 | 0 | failf(data, "Failed to resolve \"%s\" for SOCKS4 connect.", |
391 | 0 | sx->hostname); |
392 | |
|
393 | 0 | if(!hp) |
394 | 0 | return CURLPX_RESOLVE_HOST; |
395 | 0 | } |
396 | | /* FALLTHROUGH */ |
397 | 0 | CONNECT_REQ_INIT: |
398 | 0 | case CONNECT_REQ_INIT: |
399 | | /* |
400 | | * This is currently not supporting "Identification Protocol (RFC1413)". |
401 | | */ |
402 | 0 | socksreq[8] = 0; /* ensure empty userid is NUL-terminated */ |
403 | 0 | if(sx->proxy_user) { |
404 | 0 | size_t plen = strlen(sx->proxy_user); |
405 | 0 | if(plen >= (size_t)data->set.buffer_size - 8) { |
406 | 0 | failf(data, "Too long SOCKS proxy user name, can't use"); |
407 | 0 | return CURLPX_LONG_USER; |
408 | 0 | } |
409 | | /* copy the proxy name WITH trailing zero */ |
410 | 0 | memcpy(socksreq + 8, sx->proxy_user, plen + 1); |
411 | 0 | } |
412 | | |
413 | | /* |
414 | | * Make connection |
415 | | */ |
416 | 0 | { |
417 | 0 | size_t packetsize = 9 + |
418 | 0 | strlen((char *)socksreq + 8); /* size including NUL */ |
419 | | |
420 | | /* If SOCKS4a, set special invalid IP address 0.0.0.x */ |
421 | 0 | if(protocol4a) { |
422 | 0 | size_t hostnamelen = 0; |
423 | 0 | socksreq[4] = 0; |
424 | 0 | socksreq[5] = 0; |
425 | 0 | socksreq[6] = 0; |
426 | 0 | socksreq[7] = 1; |
427 | | /* append hostname */ |
428 | 0 | hostnamelen = strlen(sx->hostname) + 1; /* length including NUL */ |
429 | 0 | if(hostnamelen <= 255) |
430 | 0 | strcpy((char *)socksreq + packetsize, sx->hostname); |
431 | 0 | else { |
432 | 0 | failf(data, "SOCKS4: too long host name"); |
433 | 0 | return CURLPX_LONG_HOSTNAME; |
434 | 0 | } |
435 | 0 | packetsize += hostnamelen; |
436 | 0 | } |
437 | 0 | sx->outp = socksreq; |
438 | 0 | sx->outstanding = packetsize; |
439 | 0 | sxstate(sx, data, CONNECT_REQ_SENDING); |
440 | 0 | } |
441 | | /* FALLTHROUGH */ |
442 | 0 | case CONNECT_REQ_SENDING: |
443 | | /* Send request */ |
444 | 0 | presult = socks_state_send(cf, sx, data, CURLPX_SEND_CONNECT, |
445 | 0 | "SOCKS4 connect request"); |
446 | 0 | if(CURLPX_OK != presult) |
447 | 0 | return presult; |
448 | 0 | else if(sx->outstanding) { |
449 | | /* remain in sending state */ |
450 | 0 | return CURLPX_OK; |
451 | 0 | } |
452 | | /* done sending! */ |
453 | 0 | sx->outstanding = 8; /* receive data size */ |
454 | 0 | sx->outp = socksreq; |
455 | 0 | sxstate(sx, data, CONNECT_SOCKS_READ); |
456 | | |
457 | | /* FALLTHROUGH */ |
458 | 0 | case CONNECT_SOCKS_READ: |
459 | | /* Receive response */ |
460 | 0 | presult = socks_state_recv(cf, sx, data, CURLPX_RECV_CONNECT, |
461 | 0 | "connect request ack"); |
462 | 0 | if(CURLPX_OK != presult) |
463 | 0 | return presult; |
464 | 0 | else if(sx->outstanding) { |
465 | | /* remain in reading state */ |
466 | 0 | return CURLPX_OK; |
467 | 0 | } |
468 | 0 | sxstate(sx, data, CONNECT_DONE); |
469 | 0 | break; |
470 | 0 | default: /* lots of unused states in SOCKS4 */ |
471 | 0 | break; |
472 | 0 | } |
473 | | |
474 | | /* |
475 | | * Response format |
476 | | * |
477 | | * +----+----+----+----+----+----+----+----+ |
478 | | * | VN | CD | DSTPORT | DSTIP | |
479 | | * +----+----+----+----+----+----+----+----+ |
480 | | * # of bytes: 1 1 2 4 |
481 | | * |
482 | | * VN is the version of the reply code and should be 0. CD is the result |
483 | | * code with one of the following values: |
484 | | * |
485 | | * 90: request granted |
486 | | * 91: request rejected or failed |
487 | | * 92: request rejected because SOCKS server cannot connect to |
488 | | * identd on the client |
489 | | * 93: request rejected because the client program and identd |
490 | | * report different user-ids |
491 | | */ |
492 | | |
493 | | /* wrong version ? */ |
494 | 0 | if(socksreq[0]) { |
495 | 0 | failf(data, |
496 | 0 | "SOCKS4 reply has wrong version, version should be 0."); |
497 | 0 | return CURLPX_BAD_VERSION; |
498 | 0 | } |
499 | | |
500 | | /* Result */ |
501 | 0 | switch(socksreq[1]) { |
502 | 0 | case 90: |
503 | 0 | infof(data, "SOCKS4%s request granted.", protocol4a?"a":""); |
504 | 0 | break; |
505 | 0 | case 91: |
506 | 0 | failf(data, |
507 | 0 | "Can't complete SOCKS4 connection to %d.%d.%d.%d:%d. (%d)" |
508 | 0 | ", request rejected or failed.", |
509 | 0 | socksreq[4], socksreq[5], socksreq[6], socksreq[7], |
510 | 0 | (((unsigned char)socksreq[2] << 8) | (unsigned char)socksreq[3]), |
511 | 0 | (unsigned char)socksreq[1]); |
512 | 0 | return CURLPX_REQUEST_FAILED; |
513 | 0 | case 92: |
514 | 0 | failf(data, |
515 | 0 | "Can't complete SOCKS4 connection to %d.%d.%d.%d:%d. (%d)" |
516 | 0 | ", request rejected because SOCKS server cannot connect to " |
517 | 0 | "identd on the client.", |
518 | 0 | socksreq[4], socksreq[5], socksreq[6], socksreq[7], |
519 | 0 | (((unsigned char)socksreq[2] << 8) | (unsigned char)socksreq[3]), |
520 | 0 | (unsigned char)socksreq[1]); |
521 | 0 | return CURLPX_IDENTD; |
522 | 0 | case 93: |
523 | 0 | failf(data, |
524 | 0 | "Can't complete SOCKS4 connection to %d.%d.%d.%d:%d. (%d)" |
525 | 0 | ", request rejected because the client program and identd " |
526 | 0 | "report different user-ids.", |
527 | 0 | socksreq[4], socksreq[5], socksreq[6], socksreq[7], |
528 | 0 | (((unsigned char)socksreq[2] << 8) | (unsigned char)socksreq[3]), |
529 | 0 | (unsigned char)socksreq[1]); |
530 | 0 | return CURLPX_IDENTD_DIFFER; |
531 | 0 | default: |
532 | 0 | failf(data, |
533 | 0 | "Can't complete SOCKS4 connection to %d.%d.%d.%d:%d. (%d)" |
534 | 0 | ", Unknown.", |
535 | 0 | socksreq[4], socksreq[5], socksreq[6], socksreq[7], |
536 | 0 | (((unsigned char)socksreq[2] << 8) | (unsigned char)socksreq[3]), |
537 | 0 | (unsigned char)socksreq[1]); |
538 | 0 | return CURLPX_UNKNOWN_FAIL; |
539 | 0 | } |
540 | | |
541 | 0 | return CURLPX_OK; /* Proxy was successful! */ |
542 | 0 | } |
543 | | |
544 | | /* |
545 | | * This function logs in to a SOCKS5 proxy and sends the specifics to the final |
546 | | * destination server. |
547 | | */ |
548 | | static CURLproxycode do_SOCKS5(struct Curl_cfilter *cf, |
549 | | struct socks_state *sx, |
550 | | struct Curl_easy *data) |
551 | 0 | { |
552 | | /* |
553 | | According to the RFC1928, section "6. Replies". This is what a SOCK5 |
554 | | replies: |
555 | | |
556 | | +----+-----+-------+------+----------+----------+ |
557 | | |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT | |
558 | | +----+-----+-------+------+----------+----------+ |
559 | | | 1 | 1 | X'00' | 1 | Variable | 2 | |
560 | | +----+-----+-------+------+----------+----------+ |
561 | | |
562 | | Where: |
563 | | |
564 | | o VER protocol version: X'05' |
565 | | o REP Reply field: |
566 | | o X'00' succeeded |
567 | | */ |
568 | 0 | struct connectdata *conn = cf->conn; |
569 | 0 | unsigned char *socksreq = (unsigned char *)data->state.buffer; |
570 | 0 | int idx; |
571 | 0 | CURLcode result; |
572 | 0 | CURLproxycode presult; |
573 | 0 | bool socks5_resolve_local = |
574 | 0 | (conn->socks_proxy.proxytype == CURLPROXY_SOCKS5) ? TRUE : FALSE; |
575 | 0 | const size_t hostname_len = strlen(sx->hostname); |
576 | 0 | ssize_t len = 0; |
577 | 0 | const unsigned char auth = data->set.socks5auth; |
578 | 0 | bool allow_gssapi = FALSE; |
579 | 0 | struct Curl_dns_entry *dns = NULL; |
580 | |
|
581 | 0 | DEBUGASSERT(auth & (CURLAUTH_BASIC | CURLAUTH_GSSAPI)); |
582 | 0 | switch(sx->state) { |
583 | 0 | case CONNECT_SOCKS_INIT: |
584 | 0 | if(conn->bits.httpproxy) |
585 | 0 | infof(data, "SOCKS5: connecting to HTTP proxy %s port %d", |
586 | 0 | sx->hostname, sx->remote_port); |
587 | | |
588 | | /* RFC1928 chapter 5 specifies max 255 chars for domain name in packet */ |
589 | 0 | if(!socks5_resolve_local && hostname_len > 255) { |
590 | 0 | failf(data, "SOCKS5: the destination hostname is too long to be " |
591 | 0 | "resolved remotely by the proxy."); |
592 | 0 | return CURLPX_LONG_HOSTNAME; |
593 | 0 | } |
594 | | |
595 | 0 | if(auth & ~(CURLAUTH_BASIC | CURLAUTH_GSSAPI)) |
596 | 0 | infof(data, |
597 | 0 | "warning: unsupported value passed to CURLOPT_SOCKS5_AUTH: %u", |
598 | 0 | auth); |
599 | 0 | if(!(auth & CURLAUTH_BASIC)) |
600 | | /* disable username/password auth */ |
601 | 0 | sx->proxy_user = NULL; |
602 | | #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
603 | | if(auth & CURLAUTH_GSSAPI) |
604 | | allow_gssapi = TRUE; |
605 | | #endif |
606 | |
|
607 | 0 | idx = 0; |
608 | 0 | socksreq[idx++] = 5; /* version */ |
609 | 0 | idx++; /* number of authentication methods */ |
610 | 0 | socksreq[idx++] = 0; /* no authentication */ |
611 | 0 | if(allow_gssapi) |
612 | 0 | socksreq[idx++] = 1; /* GSS-API */ |
613 | 0 | if(sx->proxy_user) |
614 | 0 | socksreq[idx++] = 2; /* username/password */ |
615 | | /* write the number of authentication methods */ |
616 | 0 | socksreq[1] = (unsigned char) (idx - 2); |
617 | |
|
618 | 0 | sx->outp = socksreq; |
619 | 0 | sx->outstanding = idx; |
620 | 0 | presult = socks_state_send(cf, sx, data, CURLPX_SEND_CONNECT, |
621 | 0 | "initial SOCKS5 request"); |
622 | 0 | if(CURLPX_OK != presult) |
623 | 0 | return presult; |
624 | 0 | else if(sx->outstanding) { |
625 | | /* remain in sending state */ |
626 | 0 | return CURLPX_OK; |
627 | 0 | } |
628 | 0 | sxstate(sx, data, CONNECT_SOCKS_READ); |
629 | 0 | goto CONNECT_SOCKS_READ_INIT; |
630 | 0 | case CONNECT_SOCKS_SEND: |
631 | 0 | presult = socks_state_send(cf, sx, data, CURLPX_SEND_CONNECT, |
632 | 0 | "initial SOCKS5 request"); |
633 | 0 | if(CURLPX_OK != presult) |
634 | 0 | return presult; |
635 | 0 | else if(sx->outstanding) { |
636 | | /* remain in sending state */ |
637 | 0 | return CURLPX_OK; |
638 | 0 | } |
639 | | /* FALLTHROUGH */ |
640 | 0 | CONNECT_SOCKS_READ_INIT: |
641 | 0 | case CONNECT_SOCKS_READ_INIT: |
642 | 0 | sx->outstanding = 2; /* expect two bytes */ |
643 | 0 | sx->outp = socksreq; /* store it here */ |
644 | | /* FALLTHROUGH */ |
645 | 0 | case CONNECT_SOCKS_READ: |
646 | 0 | presult = socks_state_recv(cf, sx, data, CURLPX_RECV_CONNECT, |
647 | 0 | "initial SOCKS5 response"); |
648 | 0 | if(CURLPX_OK != presult) |
649 | 0 | return presult; |
650 | 0 | else if(sx->outstanding) { |
651 | | /* remain in reading state */ |
652 | 0 | return CURLPX_OK; |
653 | 0 | } |
654 | 0 | else if(socksreq[0] != 5) { |
655 | 0 | failf(data, "Received invalid version in initial SOCKS5 response."); |
656 | 0 | return CURLPX_BAD_VERSION; |
657 | 0 | } |
658 | 0 | else if(socksreq[1] == 0) { |
659 | | /* DONE! No authentication needed. Send request. */ |
660 | 0 | sxstate(sx, data, CONNECT_REQ_INIT); |
661 | 0 | goto CONNECT_REQ_INIT; |
662 | 0 | } |
663 | 0 | else if(socksreq[1] == 2) { |
664 | | /* regular name + password authentication */ |
665 | 0 | sxstate(sx, data, CONNECT_AUTH_INIT); |
666 | 0 | goto CONNECT_AUTH_INIT; |
667 | 0 | } |
668 | | #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
669 | | else if(allow_gssapi && (socksreq[1] == 1)) { |
670 | | sxstate(sx, data, CONNECT_GSSAPI_INIT); |
671 | | result = Curl_SOCKS5_gssapi_negotiate(cf, data); |
672 | | if(result) { |
673 | | failf(data, "Unable to negotiate SOCKS5 GSS-API context."); |
674 | | return CURLPX_GSSAPI; |
675 | | } |
676 | | } |
677 | | #endif |
678 | 0 | else { |
679 | | /* error */ |
680 | 0 | if(!allow_gssapi && (socksreq[1] == 1)) { |
681 | 0 | failf(data, |
682 | 0 | "SOCKS5 GSSAPI per-message authentication is not supported."); |
683 | 0 | return CURLPX_GSSAPI_PERMSG; |
684 | 0 | } |
685 | 0 | else if(socksreq[1] == 255) { |
686 | 0 | failf(data, "No authentication method was acceptable."); |
687 | 0 | return CURLPX_NO_AUTH; |
688 | 0 | } |
689 | 0 | } |
690 | 0 | failf(data, |
691 | 0 | "Undocumented SOCKS5 mode attempted to be used by server."); |
692 | 0 | return CURLPX_UNKNOWN_MODE; |
693 | | #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
694 | | case CONNECT_GSSAPI_INIT: |
695 | | /* GSSAPI stuff done non-blocking */ |
696 | | break; |
697 | | #endif |
698 | | |
699 | 0 | default: /* do nothing! */ |
700 | 0 | break; |
701 | | |
702 | 0 | CONNECT_AUTH_INIT: |
703 | 0 | case CONNECT_AUTH_INIT: { |
704 | | /* Needs user name and password */ |
705 | 0 | size_t proxy_user_len, proxy_password_len; |
706 | 0 | if(sx->proxy_user && sx->proxy_password) { |
707 | 0 | proxy_user_len = strlen(sx->proxy_user); |
708 | 0 | proxy_password_len = strlen(sx->proxy_password); |
709 | 0 | } |
710 | 0 | else { |
711 | 0 | proxy_user_len = 0; |
712 | 0 | proxy_password_len = 0; |
713 | 0 | } |
714 | | |
715 | | /* username/password request looks like |
716 | | * +----+------+----------+------+----------+ |
717 | | * |VER | ULEN | UNAME | PLEN | PASSWD | |
718 | | * +----+------+----------+------+----------+ |
719 | | * | 1 | 1 | 1 to 255 | 1 | 1 to 255 | |
720 | | * +----+------+----------+------+----------+ |
721 | | */ |
722 | 0 | len = 0; |
723 | 0 | socksreq[len++] = 1; /* username/pw subnegotiation version */ |
724 | 0 | socksreq[len++] = (unsigned char) proxy_user_len; |
725 | 0 | if(sx->proxy_user && proxy_user_len) { |
726 | | /* the length must fit in a single byte */ |
727 | 0 | if(proxy_user_len > 255) { |
728 | 0 | failf(data, "Excessive user name length for proxy auth"); |
729 | 0 | return CURLPX_LONG_USER; |
730 | 0 | } |
731 | 0 | memcpy(socksreq + len, sx->proxy_user, proxy_user_len); |
732 | 0 | } |
733 | 0 | len += proxy_user_len; |
734 | 0 | socksreq[len++] = (unsigned char) proxy_password_len; |
735 | 0 | if(sx->proxy_password && proxy_password_len) { |
736 | | /* the length must fit in a single byte */ |
737 | 0 | if(proxy_password_len > 255) { |
738 | 0 | failf(data, "Excessive password length for proxy auth"); |
739 | 0 | return CURLPX_LONG_PASSWD; |
740 | 0 | } |
741 | 0 | memcpy(socksreq + len, sx->proxy_password, proxy_password_len); |
742 | 0 | } |
743 | 0 | len += proxy_password_len; |
744 | 0 | sxstate(sx, data, CONNECT_AUTH_SEND); |
745 | 0 | sx->outstanding = len; |
746 | 0 | sx->outp = socksreq; |
747 | 0 | } |
748 | | /* FALLTHROUGH */ |
749 | 0 | case CONNECT_AUTH_SEND: |
750 | 0 | presult = socks_state_send(cf, sx, data, CURLPX_SEND_AUTH, |
751 | 0 | "SOCKS5 sub-negotiation request"); |
752 | 0 | if(CURLPX_OK != presult) |
753 | 0 | return presult; |
754 | 0 | else if(sx->outstanding) { |
755 | | /* remain in sending state */ |
756 | 0 | return CURLPX_OK; |
757 | 0 | } |
758 | 0 | sx->outp = socksreq; |
759 | 0 | sx->outstanding = 2; |
760 | 0 | sxstate(sx, data, CONNECT_AUTH_READ); |
761 | | /* FALLTHROUGH */ |
762 | 0 | case CONNECT_AUTH_READ: |
763 | 0 | presult = socks_state_recv(cf, sx, data, CURLPX_RECV_AUTH, |
764 | 0 | "SOCKS5 sub-negotiation response"); |
765 | 0 | if(CURLPX_OK != presult) |
766 | 0 | return presult; |
767 | 0 | else if(sx->outstanding) { |
768 | | /* remain in reading state */ |
769 | 0 | return CURLPX_OK; |
770 | 0 | } |
771 | | /* ignore the first (VER) byte */ |
772 | 0 | else if(socksreq[1]) { /* status */ |
773 | 0 | failf(data, "User was rejected by the SOCKS5 server (%d %d).", |
774 | 0 | socksreq[0], socksreq[1]); |
775 | 0 | return CURLPX_USER_REJECTED; |
776 | 0 | } |
777 | | |
778 | | /* Everything is good so far, user was authenticated! */ |
779 | 0 | sxstate(sx, data, CONNECT_REQ_INIT); |
780 | | /* FALLTHROUGH */ |
781 | 0 | CONNECT_REQ_INIT: |
782 | 0 | case CONNECT_REQ_INIT: |
783 | 0 | if(socks5_resolve_local) { |
784 | 0 | enum resolve_t rc = Curl_resolv(data, sx->hostname, sx->remote_port, |
785 | 0 | TRUE, &dns); |
786 | |
|
787 | 0 | if(rc == CURLRESOLV_ERROR) |
788 | 0 | return CURLPX_RESOLVE_HOST; |
789 | | |
790 | 0 | if(rc == CURLRESOLV_PENDING) { |
791 | 0 | sxstate(sx, data, CONNECT_RESOLVING); |
792 | 0 | return CURLPX_OK; |
793 | 0 | } |
794 | 0 | sxstate(sx, data, CONNECT_RESOLVED); |
795 | 0 | goto CONNECT_RESOLVED; |
796 | 0 | } |
797 | 0 | goto CONNECT_RESOLVE_REMOTE; |
798 | | |
799 | 0 | case CONNECT_RESOLVING: |
800 | | /* check if we have the name resolved by now */ |
801 | 0 | dns = Curl_fetch_addr(data, sx->hostname, sx->remote_port); |
802 | |
|
803 | 0 | if(dns) { |
804 | | #ifdef CURLRES_ASYNCH |
805 | | data->state.async.dns = dns; |
806 | | data->state.async.done = TRUE; |
807 | | #endif |
808 | 0 | infof(data, "SOCKS5: hostname '%s' found", sx->hostname); |
809 | 0 | } |
810 | |
|
811 | 0 | if(!dns) { |
812 | 0 | result = Curl_resolv_check(data, &dns); |
813 | 0 | if(!dns) { |
814 | 0 | if(result) |
815 | 0 | return CURLPX_RESOLVE_HOST; |
816 | 0 | return CURLPX_OK; |
817 | 0 | } |
818 | 0 | } |
819 | | /* FALLTHROUGH */ |
820 | 0 | CONNECT_RESOLVED: |
821 | 0 | case CONNECT_RESOLVED: { |
822 | 0 | char dest[MAX_IPADR_LEN] = "unknown"; /* printable address */ |
823 | 0 | struct Curl_addrinfo *hp = NULL; |
824 | 0 | if(dns) |
825 | 0 | hp = dns->addr; |
826 | 0 | if(!hp) { |
827 | 0 | failf(data, "Failed to resolve \"%s\" for SOCKS5 connect.", |
828 | 0 | sx->hostname); |
829 | 0 | return CURLPX_RESOLVE_HOST; |
830 | 0 | } |
831 | | |
832 | 0 | Curl_printable_address(hp, dest, sizeof(dest)); |
833 | |
|
834 | 0 | len = 0; |
835 | 0 | socksreq[len++] = 5; /* version (SOCKS5) */ |
836 | 0 | socksreq[len++] = 1; /* connect */ |
837 | 0 | socksreq[len++] = 0; /* must be zero */ |
838 | 0 | if(hp->ai_family == AF_INET) { |
839 | 0 | int i; |
840 | 0 | struct sockaddr_in *saddr_in; |
841 | 0 | socksreq[len++] = 1; /* ATYP: IPv4 = 1 */ |
842 | |
|
843 | 0 | saddr_in = (struct sockaddr_in *)(void *)hp->ai_addr; |
844 | 0 | for(i = 0; i < 4; i++) { |
845 | 0 | socksreq[len++] = ((unsigned char *)&saddr_in->sin_addr.s_addr)[i]; |
846 | 0 | } |
847 | |
|
848 | 0 | infof(data, "SOCKS5 connect to %s:%d (locally resolved)", dest, |
849 | 0 | sx->remote_port); |
850 | 0 | } |
851 | 0 | #ifdef ENABLE_IPV6 |
852 | 0 | else if(hp->ai_family == AF_INET6) { |
853 | 0 | int i; |
854 | 0 | struct sockaddr_in6 *saddr_in6; |
855 | 0 | socksreq[len++] = 4; /* ATYP: IPv6 = 4 */ |
856 | |
|
857 | 0 | saddr_in6 = (struct sockaddr_in6 *)(void *)hp->ai_addr; |
858 | 0 | for(i = 0; i < 16; i++) { |
859 | 0 | socksreq[len++] = |
860 | 0 | ((unsigned char *)&saddr_in6->sin6_addr.s6_addr)[i]; |
861 | 0 | } |
862 | |
|
863 | 0 | infof(data, "SOCKS5 connect to [%s]:%d (locally resolved)", dest, |
864 | 0 | sx->remote_port); |
865 | 0 | } |
866 | 0 | #endif |
867 | 0 | else { |
868 | 0 | hp = NULL; /* fail! */ |
869 | 0 | failf(data, "SOCKS5 connection to %s not supported", dest); |
870 | 0 | } |
871 | |
|
872 | 0 | Curl_resolv_unlock(data, dns); /* not used anymore from now on */ |
873 | 0 | goto CONNECT_REQ_SEND; |
874 | 0 | } |
875 | 0 | CONNECT_RESOLVE_REMOTE: |
876 | 0 | case CONNECT_RESOLVE_REMOTE: |
877 | | /* Authentication is complete, now specify destination to the proxy */ |
878 | 0 | len = 0; |
879 | 0 | socksreq[len++] = 5; /* version (SOCKS5) */ |
880 | 0 | socksreq[len++] = 1; /* connect */ |
881 | 0 | socksreq[len++] = 0; /* must be zero */ |
882 | |
|
883 | 0 | if(!socks5_resolve_local) { |
884 | | /* ATYP: domain name = 3, |
885 | | IPv6 == 4, |
886 | | IPv4 == 1 */ |
887 | 0 | unsigned char ip4[4]; |
888 | 0 | #ifdef ENABLE_IPV6 |
889 | 0 | if(conn->bits.ipv6_ip) { |
890 | 0 | char ip6[16]; |
891 | 0 | if(1 != Curl_inet_pton(AF_INET6, sx->hostname, ip6)) |
892 | 0 | return CURLPX_BAD_ADDRESS_TYPE; |
893 | 0 | socksreq[len++] = 4; |
894 | 0 | memcpy(&socksreq[len], ip6, sizeof(ip6)); |
895 | 0 | len += sizeof(ip6); |
896 | 0 | } |
897 | 0 | else |
898 | 0 | #endif |
899 | 0 | if(1 == Curl_inet_pton(AF_INET, sx->hostname, ip4)) { |
900 | 0 | socksreq[len++] = 1; |
901 | 0 | memcpy(&socksreq[len], ip4, sizeof(ip4)); |
902 | 0 | len += sizeof(ip4); |
903 | 0 | } |
904 | 0 | else { |
905 | 0 | socksreq[len++] = 3; |
906 | 0 | socksreq[len++] = (unsigned char) hostname_len; /* one byte length */ |
907 | 0 | memcpy(&socksreq[len], sx->hostname, hostname_len); /* w/o NULL */ |
908 | 0 | len += hostname_len; |
909 | 0 | } |
910 | 0 | infof(data, "SOCKS5 connect to %s:%d (remotely resolved)", |
911 | 0 | sx->hostname, sx->remote_port); |
912 | 0 | } |
913 | | /* FALLTHROUGH */ |
914 | | |
915 | 0 | CONNECT_REQ_SEND: |
916 | 0 | case CONNECT_REQ_SEND: |
917 | | /* PORT MSB */ |
918 | 0 | socksreq[len++] = (unsigned char)((sx->remote_port >> 8) & 0xff); |
919 | | /* PORT LSB */ |
920 | 0 | socksreq[len++] = (unsigned char)(sx->remote_port & 0xff); |
921 | |
|
922 | | #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
923 | | if(conn->socks5_gssapi_enctype) { |
924 | | failf(data, "SOCKS5 GSS-API protection not yet implemented."); |
925 | | return CURLPX_GSSAPI_PROTECTION; |
926 | | } |
927 | | #endif |
928 | 0 | sx->outp = socksreq; |
929 | 0 | sx->outstanding = len; |
930 | 0 | sxstate(sx, data, CONNECT_REQ_SENDING); |
931 | | /* FALLTHROUGH */ |
932 | 0 | case CONNECT_REQ_SENDING: |
933 | 0 | presult = socks_state_send(cf, sx, data, CURLPX_SEND_REQUEST, |
934 | 0 | "SOCKS5 connect request"); |
935 | 0 | if(CURLPX_OK != presult) |
936 | 0 | return presult; |
937 | 0 | else if(sx->outstanding) { |
938 | | /* remain in send state */ |
939 | 0 | return CURLPX_OK; |
940 | 0 | } |
941 | | #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
942 | | if(conn->socks5_gssapi_enctype) { |
943 | | failf(data, "SOCKS5 GSS-API protection not yet implemented."); |
944 | | return CURLPX_GSSAPI_PROTECTION; |
945 | | } |
946 | | #endif |
947 | 0 | sx->outstanding = 10; /* minimum packet size is 10 */ |
948 | 0 | sx->outp = socksreq; |
949 | 0 | sxstate(sx, data, CONNECT_REQ_READ); |
950 | | /* FALLTHROUGH */ |
951 | 0 | case CONNECT_REQ_READ: |
952 | 0 | presult = socks_state_recv(cf, sx, data, CURLPX_RECV_REQACK, |
953 | 0 | "SOCKS5 connect request ack"); |
954 | 0 | if(CURLPX_OK != presult) |
955 | 0 | return presult; |
956 | 0 | else if(sx->outstanding) { |
957 | | /* remain in reading state */ |
958 | 0 | return CURLPX_OK; |
959 | 0 | } |
960 | 0 | else if(socksreq[0] != 5) { /* version */ |
961 | 0 | failf(data, |
962 | 0 | "SOCKS5 reply has wrong version, version should be 5."); |
963 | 0 | return CURLPX_BAD_VERSION; |
964 | 0 | } |
965 | 0 | else if(socksreq[1]) { /* Anything besides 0 is an error */ |
966 | 0 | CURLproxycode rc = CURLPX_REPLY_UNASSIGNED; |
967 | 0 | int code = socksreq[1]; |
968 | 0 | failf(data, "Can't complete SOCKS5 connection to %s. (%d)", |
969 | 0 | sx->hostname, (unsigned char)socksreq[1]); |
970 | 0 | if(code < 9) { |
971 | | /* RFC 1928 section 6 lists: */ |
972 | 0 | static const CURLproxycode lookup[] = { |
973 | 0 | CURLPX_OK, |
974 | 0 | CURLPX_REPLY_GENERAL_SERVER_FAILURE, |
975 | 0 | CURLPX_REPLY_NOT_ALLOWED, |
976 | 0 | CURLPX_REPLY_NETWORK_UNREACHABLE, |
977 | 0 | CURLPX_REPLY_HOST_UNREACHABLE, |
978 | 0 | CURLPX_REPLY_CONNECTION_REFUSED, |
979 | 0 | CURLPX_REPLY_TTL_EXPIRED, |
980 | 0 | CURLPX_REPLY_COMMAND_NOT_SUPPORTED, |
981 | 0 | CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED, |
982 | 0 | }; |
983 | 0 | rc = lookup[code]; |
984 | 0 | } |
985 | 0 | return rc; |
986 | 0 | } |
987 | | |
988 | | /* Fix: in general, returned BND.ADDR is variable length parameter by RFC |
989 | | 1928, so the reply packet should be read until the end to avoid errors |
990 | | at subsequent protocol level. |
991 | | |
992 | | +----+-----+-------+------+----------+----------+ |
993 | | |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT | |
994 | | +----+-----+-------+------+----------+----------+ |
995 | | | 1 | 1 | X'00' | 1 | Variable | 2 | |
996 | | +----+-----+-------+------+----------+----------+ |
997 | | |
998 | | ATYP: |
999 | | o IP v4 address: X'01', BND.ADDR = 4 byte |
1000 | | o domain name: X'03', BND.ADDR = [ 1 byte length, string ] |
1001 | | o IP v6 address: X'04', BND.ADDR = 16 byte |
1002 | | */ |
1003 | | |
1004 | | /* Calculate real packet size */ |
1005 | 0 | if(socksreq[3] == 3) { |
1006 | | /* domain name */ |
1007 | 0 | int addrlen = (int) socksreq[4]; |
1008 | 0 | len = 5 + addrlen + 2; |
1009 | 0 | } |
1010 | 0 | else if(socksreq[3] == 4) { |
1011 | | /* IPv6 */ |
1012 | 0 | len = 4 + 16 + 2; |
1013 | 0 | } |
1014 | 0 | else if(socksreq[3] == 1) { |
1015 | 0 | len = 4 + 4 + 2; |
1016 | 0 | } |
1017 | 0 | else { |
1018 | 0 | failf(data, "SOCKS5 reply has wrong address type."); |
1019 | 0 | return CURLPX_BAD_ADDRESS_TYPE; |
1020 | 0 | } |
1021 | | |
1022 | | /* At this point we already read first 10 bytes */ |
1023 | | #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
1024 | | if(!conn->socks5_gssapi_enctype) { |
1025 | | /* decrypt_gssapi_blockread already read the whole packet */ |
1026 | | #endif |
1027 | 0 | if(len > 10) { |
1028 | 0 | sx->outstanding = len - 10; /* get the rest */ |
1029 | 0 | sx->outp = &socksreq[10]; |
1030 | 0 | sxstate(sx, data, CONNECT_REQ_READ_MORE); |
1031 | 0 | } |
1032 | 0 | else { |
1033 | 0 | sxstate(sx, data, CONNECT_DONE); |
1034 | 0 | break; |
1035 | 0 | } |
1036 | | #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
1037 | | } |
1038 | | #endif |
1039 | | /* FALLTHROUGH */ |
1040 | 0 | case CONNECT_REQ_READ_MORE: |
1041 | 0 | presult = socks_state_recv(cf, sx, data, CURLPX_RECV_ADDRESS, |
1042 | 0 | "SOCKS5 connect request address"); |
1043 | 0 | if(CURLPX_OK != presult) |
1044 | 0 | return presult; |
1045 | 0 | else if(sx->outstanding) { |
1046 | | /* remain in reading state */ |
1047 | 0 | return CURLPX_OK; |
1048 | 0 | } |
1049 | 0 | sxstate(sx, data, CONNECT_DONE); |
1050 | 0 | } |
1051 | 0 | infof(data, "SOCKS5 request granted."); |
1052 | |
|
1053 | 0 | return CURLPX_OK; /* Proxy was successful! */ |
1054 | 0 | } |
1055 | | |
1056 | | static CURLcode connect_SOCKS(struct Curl_cfilter *cf, |
1057 | | struct socks_state *sxstate, |
1058 | | struct Curl_easy *data) |
1059 | 0 | { |
1060 | 0 | CURLcode result = CURLE_OK; |
1061 | 0 | CURLproxycode pxresult = CURLPX_OK; |
1062 | 0 | struct connectdata *conn = cf->conn; |
1063 | |
|
1064 | 0 | switch(conn->socks_proxy.proxytype) { |
1065 | 0 | case CURLPROXY_SOCKS5: |
1066 | 0 | case CURLPROXY_SOCKS5_HOSTNAME: |
1067 | 0 | pxresult = do_SOCKS5(cf, sxstate, data); |
1068 | 0 | break; |
1069 | | |
1070 | 0 | case CURLPROXY_SOCKS4: |
1071 | 0 | case CURLPROXY_SOCKS4A: |
1072 | 0 | pxresult = do_SOCKS4(cf, sxstate, data); |
1073 | 0 | break; |
1074 | | |
1075 | 0 | default: |
1076 | 0 | failf(data, "unknown proxytype option given"); |
1077 | 0 | result = CURLE_COULDNT_CONNECT; |
1078 | 0 | } /* switch proxytype */ |
1079 | 0 | if(pxresult) { |
1080 | 0 | result = CURLE_PROXY; |
1081 | 0 | data->info.pxcode = pxresult; |
1082 | 0 | } |
1083 | |
|
1084 | 0 | return result; |
1085 | 0 | } |
1086 | | |
1087 | | static void socks_proxy_cf_free(struct Curl_cfilter *cf) |
1088 | 0 | { |
1089 | 0 | struct socks_state *sxstate = cf->ctx; |
1090 | 0 | if(sxstate) { |
1091 | 0 | free(sxstate); |
1092 | 0 | cf->ctx = NULL; |
1093 | 0 | } |
1094 | 0 | } |
1095 | | |
1096 | | /* After a TCP connection to the proxy has been verified, this function does |
1097 | | the next magic steps. If 'done' isn't set TRUE, it is not done yet and |
1098 | | must be called again. |
1099 | | |
1100 | | Note: this function's sub-functions call failf() |
1101 | | |
1102 | | */ |
1103 | | static CURLcode socks_proxy_cf_connect(struct Curl_cfilter *cf, |
1104 | | struct Curl_easy *data, |
1105 | | bool blocking, bool *done) |
1106 | 0 | { |
1107 | 0 | CURLcode result; |
1108 | 0 | struct connectdata *conn = cf->conn; |
1109 | 0 | int sockindex = cf->sockindex; |
1110 | 0 | struct socks_state *sx = cf->ctx; |
1111 | |
|
1112 | 0 | if(cf->connected) { |
1113 | 0 | *done = TRUE; |
1114 | 0 | return CURLE_OK; |
1115 | 0 | } |
1116 | | |
1117 | 0 | result = cf->next->cft->do_connect(cf->next, data, blocking, done); |
1118 | 0 | if(result || !*done) |
1119 | 0 | return result; |
1120 | | |
1121 | 0 | if(!sx) { |
1122 | 0 | sx = calloc(sizeof(*sx), 1); |
1123 | 0 | if(!sx) |
1124 | 0 | return CURLE_OUT_OF_MEMORY; |
1125 | 0 | cf->ctx = sx; |
1126 | 0 | } |
1127 | | |
1128 | 0 | if(sx->state == CONNECT_INIT) { |
1129 | | /* for the secondary socket (FTP), use the "connect to host" |
1130 | | * but ignore the "connect to port" (use the secondary port) |
1131 | | */ |
1132 | 0 | sxstate(sx, data, CONNECT_SOCKS_INIT); |
1133 | 0 | sx->hostname = |
1134 | 0 | conn->bits.httpproxy ? |
1135 | 0 | conn->http_proxy.host.name : |
1136 | 0 | conn->bits.conn_to_host ? |
1137 | 0 | conn->conn_to_host.name : |
1138 | 0 | sockindex == SECONDARYSOCKET ? |
1139 | 0 | conn->secondaryhostname : conn->host.name; |
1140 | 0 | sx->remote_port = |
1141 | 0 | conn->bits.httpproxy ? (int)conn->http_proxy.port : |
1142 | 0 | sockindex == SECONDARYSOCKET ? conn->secondary_port : |
1143 | 0 | conn->bits.conn_to_port ? conn->conn_to_port : |
1144 | 0 | conn->remote_port; |
1145 | 0 | sx->proxy_user = conn->socks_proxy.user; |
1146 | 0 | sx->proxy_password = conn->socks_proxy.passwd; |
1147 | 0 | } |
1148 | |
|
1149 | 0 | result = connect_SOCKS(cf, sx, data); |
1150 | 0 | if(!result && sx->state == CONNECT_DONE) { |
1151 | 0 | cf->connected = TRUE; |
1152 | 0 | Curl_verboseconnect(data, conn); |
1153 | 0 | socks_proxy_cf_free(cf); |
1154 | 0 | } |
1155 | |
|
1156 | 0 | *done = cf->connected; |
1157 | 0 | return result; |
1158 | 0 | } |
1159 | | |
1160 | | static int socks_cf_get_select_socks(struct Curl_cfilter *cf, |
1161 | | struct Curl_easy *data, |
1162 | | curl_socket_t *socks) |
1163 | 0 | { |
1164 | 0 | struct socks_state *sx = cf->ctx; |
1165 | 0 | int fds; |
1166 | |
|
1167 | 0 | fds = cf->next->cft->get_select_socks(cf->next, data, socks); |
1168 | 0 | if(!fds && cf->next->connected && !cf->connected && sx) { |
1169 | | /* If we are not connected, the filter below is and has nothing |
1170 | | * to wait on, we determine what to wait for. */ |
1171 | 0 | socks[0] = Curl_conn_cf_get_socket(cf, data); |
1172 | 0 | switch(sx->state) { |
1173 | 0 | case CONNECT_RESOLVING: |
1174 | 0 | case CONNECT_SOCKS_READ: |
1175 | 0 | case CONNECT_AUTH_READ: |
1176 | 0 | case CONNECT_REQ_READ: |
1177 | 0 | case CONNECT_REQ_READ_MORE: |
1178 | 0 | fds = GETSOCK_READSOCK(0); |
1179 | 0 | break; |
1180 | 0 | default: |
1181 | 0 | fds = GETSOCK_WRITESOCK(0); |
1182 | 0 | break; |
1183 | 0 | } |
1184 | 0 | } |
1185 | 0 | return fds; |
1186 | 0 | } |
1187 | | |
1188 | | static void socks_proxy_cf_close(struct Curl_cfilter *cf, |
1189 | | struct Curl_easy *data) |
1190 | 0 | { |
1191 | |
|
1192 | 0 | DEBUGASSERT(cf->next); |
1193 | 0 | cf->connected = FALSE; |
1194 | 0 | socks_proxy_cf_free(cf); |
1195 | 0 | cf->next->cft->do_close(cf->next, data); |
1196 | 0 | } |
1197 | | |
1198 | | static void socks_proxy_cf_destroy(struct Curl_cfilter *cf, |
1199 | | struct Curl_easy *data) |
1200 | 0 | { |
1201 | 0 | (void)data; |
1202 | 0 | socks_proxy_cf_free(cf); |
1203 | 0 | } |
1204 | | |
1205 | | static void socks_cf_get_host(struct Curl_cfilter *cf, |
1206 | | struct Curl_easy *data, |
1207 | | const char **phost, |
1208 | | const char **pdisplay_host, |
1209 | | int *pport) |
1210 | 0 | { |
1211 | 0 | (void)data; |
1212 | 0 | if(!cf->connected) { |
1213 | 0 | *phost = cf->conn->socks_proxy.host.name; |
1214 | 0 | *pdisplay_host = cf->conn->http_proxy.host.dispname; |
1215 | 0 | *pport = (int)cf->conn->socks_proxy.port; |
1216 | 0 | } |
1217 | 0 | else { |
1218 | 0 | cf->next->cft->get_host(cf->next, data, phost, pdisplay_host, pport); |
1219 | 0 | } |
1220 | 0 | } |
1221 | | |
1222 | | struct Curl_cftype Curl_cft_socks_proxy = { |
1223 | | "SOCKS-PROXYY", |
1224 | | CF_TYPE_IP_CONNECT, |
1225 | | 0, |
1226 | | socks_proxy_cf_destroy, |
1227 | | socks_proxy_cf_connect, |
1228 | | socks_proxy_cf_close, |
1229 | | socks_cf_get_host, |
1230 | | socks_cf_get_select_socks, |
1231 | | Curl_cf_def_data_pending, |
1232 | | Curl_cf_def_send, |
1233 | | Curl_cf_def_recv, |
1234 | | Curl_cf_def_cntrl, |
1235 | | Curl_cf_def_conn_is_alive, |
1236 | | Curl_cf_def_conn_keep_alive, |
1237 | | Curl_cf_def_query, |
1238 | | }; |
1239 | | |
1240 | | CURLcode Curl_cf_socks_proxy_insert_after(struct Curl_cfilter *cf_at, |
1241 | | struct Curl_easy *data) |
1242 | 0 | { |
1243 | 0 | struct Curl_cfilter *cf; |
1244 | 0 | CURLcode result; |
1245 | |
|
1246 | 0 | (void)data; |
1247 | 0 | result = Curl_cf_create(&cf, &Curl_cft_socks_proxy, NULL); |
1248 | 0 | if(!result) |
1249 | 0 | Curl_conn_cf_insert_after(cf_at, cf); |
1250 | 0 | return result; |
1251 | 0 | } |
1252 | | |
1253 | | #endif /* CURL_DISABLE_PROXY */ |