1 | /*************************************************************************** |
2 | * _ _ ____ _ |
3 | * Project ___| | | | _ \| | |
4 | * / __| | | | |_) | | |
5 | * | (__| |_| | _ <| |___ |
6 | * \___|\___/|_| \_\_____| |
7 | * |
8 | * Copyright (C) 1998 - 2022, Daniel Stenberg, <[email protected]>, 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 "connect.h" |
40 | #include "timeval.h" |
41 | #include "socks.h" |
42 | #include "multiif.h" /* for getsock macros */ |
43 | #include "inet_pton.h" |
44 | |
45 | /* The last 3 #include files should be in this order */ |
46 | #include "curl_printf.h" |
47 | #include "curl_memory.h" |
48 | #include "memdebug.h" |
49 | |
50 | #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
51 | /* |
52 | * Helper read-from-socket functions. Does the same as Curl_read() but it |
53 | * blocks until all bytes amount of buffersize will be read. No more, no less. |
54 | * |
55 | * This is STUPID BLOCKING behavior. Only used by the SOCKS GSSAPI functions. |
56 | */ |
57 | int Curl_blockread_all(struct Curl_easy *data, /* transfer */ |
58 | curl_socket_t sockfd, /* read from this socket */ |
59 | char *buf, /* store read data here */ |
60 | ssize_t buffersize, /* max amount to read */ |
61 | ssize_t *n) /* amount bytes read */ |
62 | { |
63 | ssize_t nread = 0; |
64 | ssize_t allread = 0; |
65 | int result; |
66 | *n = 0; |
67 | for(;;) { |
68 | timediff_t timeout_ms = Curl_timeleft(data, NULL, TRUE); |
69 | if(timeout_ms < 0) { |
70 | /* we already got the timeout */ |
71 | result = CURLE_OPERATION_TIMEDOUT; |
72 | break; |
73 | } |
74 | if(!timeout_ms) |
75 | timeout_ms = TIMEDIFF_T_MAX; |
76 | if(SOCKET_READABLE(sockfd, timeout_ms) <= 0) { |
77 | result = ~CURLE_OK; |
78 | break; |
79 | } |
80 | result = Curl_read_plain(sockfd, buf, buffersize, &nread); |
81 | if(CURLE_AGAIN == result) |
82 | continue; |
83 | if(result) |
84 | break; |
85 | |
86 | if(buffersize == nread) { |
87 | allread += nread; |
88 | *n = allread; |
89 | result = CURLE_OK; |
90 | break; |
91 | } |
92 | if(!nread) { |
93 | result = ~CURLE_OK; |
94 | break; |
95 | } |
96 | |
97 | buffersize -= nread; |
98 | buf += nread; |
99 | allread += nread; |
100 | } |
101 | return result; |
102 | } |
103 | #endif |
104 | |
105 | #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS) |
106 | #define DEBUG_AND_VERBOSE |
107 | #define sxstate(x,y) socksstate(x,y, __LINE__) |
108 | #else |
109 | #define sxstate(x,y) socksstate(x,y) |
110 | #endif |
111 | |
112 | /* always use this function to change state, to make debugging easier */ |
113 | static void socksstate(struct Curl_easy *data, |
114 | enum connect_t state |
115 | #ifdef DEBUG_AND_VERBOSE |
116 | , int lineno |
117 | #endif |
118 | ) |
119 | { |
120 | struct connectdata *conn = data->conn; |
121 | enum connect_t oldstate = conn->cnnct.state; |
122 | #ifdef DEBUG_AND_VERBOSE |
123 | /* synced with the state list in urldata.h */ |
124 | static const char * const statename[] = { |
125 | "INIT" , |
126 | "SOCKS_INIT" , |
127 | "SOCKS_SEND" , |
128 | "SOCKS_READ_INIT" , |
129 | "SOCKS_READ" , |
130 | "GSSAPI_INIT" , |
131 | "AUTH_INIT" , |
132 | "AUTH_SEND" , |
133 | "AUTH_READ" , |
134 | "REQ_INIT" , |
135 | "RESOLVING" , |
136 | "RESOLVED" , |
137 | "RESOLVE_REMOTE" , |
138 | "REQ_SEND" , |
139 | "REQ_SENDING" , |
140 | "REQ_READ" , |
141 | "REQ_READ_MORE" , |
142 | "DONE" |
143 | }; |
144 | #endif |
145 | |
146 | if(oldstate == state) |
147 | /* don't bother when the new state is the same as the old state */ |
148 | return; |
149 | |
150 | conn->cnnct.state = state; |
151 | |
152 | #ifdef DEBUG_AND_VERBOSE |
153 | infof(data, |
154 | "SXSTATE: %s => %s conn %p; line %d" , |
155 | statename[oldstate], statename[conn->cnnct.state], conn, |
156 | lineno); |
157 | #endif |
158 | } |
159 | |
160 | int Curl_SOCKS_getsock(struct connectdata *conn, curl_socket_t *sock, |
161 | int sockindex) |
162 | { |
163 | int rc = 0; |
164 | sock[0] = conn->sock[sockindex]; |
165 | switch(conn->cnnct.state) { |
166 | case CONNECT_RESOLVING: |
167 | case CONNECT_SOCKS_READ: |
168 | case CONNECT_AUTH_READ: |
169 | case CONNECT_REQ_READ: |
170 | case CONNECT_REQ_READ_MORE: |
171 | rc = GETSOCK_READSOCK(0); |
172 | break; |
173 | default: |
174 | rc = GETSOCK_WRITESOCK(0); |
175 | break; |
176 | } |
177 | return rc; |
178 | } |
179 | |
180 | /* |
181 | * This function logs in to a SOCKS4 proxy and sends the specifics to the final |
182 | * destination server. |
183 | * |
184 | * Reference : |
185 | * https://www.openssh.com/txt/socks4.protocol |
186 | * |
187 | * Note : |
188 | * Set protocol4a=true for "SOCKS 4A (Simple Extension to SOCKS 4 Protocol)" |
189 | * Nonsupport "Identification Protocol (RFC1413)" |
190 | */ |
191 | CURLproxycode Curl_SOCKS4(const char *proxy_user, |
192 | const char *hostname, |
193 | int remote_port, |
194 | int sockindex, |
195 | struct Curl_easy *data, |
196 | bool *done) |
197 | { |
198 | struct connectdata *conn = data->conn; |
199 | const bool protocol4a = |
200 | (conn->socks_proxy.proxytype == CURLPROXY_SOCKS4A) ? TRUE : FALSE; |
201 | unsigned char *socksreq = (unsigned char *)data->state.buffer; |
202 | CURLcode result; |
203 | curl_socket_t sockfd = conn->sock[sockindex]; |
204 | struct connstate *sx = &conn->cnnct; |
205 | struct Curl_dns_entry *dns = NULL; |
206 | ssize_t actualread; |
207 | ssize_t written; |
208 | |
209 | /* make sure that the buffer is at least 600 bytes */ |
210 | DEBUGASSERT(READBUFFER_MIN >= 600); |
211 | |
212 | if(!SOCKS_STATE(sx->state) && !*done) |
213 | sxstate(data, CONNECT_SOCKS_INIT); |
214 | |
215 | switch(sx->state) { |
216 | case CONNECT_SOCKS_INIT: |
217 | /* SOCKS4 can only do IPv4, insist! */ |
218 | conn->ip_version = CURL_IPRESOLVE_V4; |
219 | if(conn->bits.httpproxy) |
220 | infof(data, "SOCKS4%s: connecting to HTTP proxy %s port %d" , |
221 | protocol4a ? "a" : "" , hostname, remote_port); |
222 | |
223 | infof(data, "SOCKS4 communication to %s:%d" , hostname, remote_port); |
224 | |
225 | /* |
226 | * Compose socks4 request |
227 | * |
228 | * Request format |
229 | * |
230 | * +----+----+----+----+----+----+----+----+----+----+....+----+ |
231 | * | VN | CD | DSTPORT | DSTIP | USERID |NULL| |
232 | * +----+----+----+----+----+----+----+----+----+----+....+----+ |
233 | * # of bytes: 1 1 2 4 variable 1 |
234 | */ |
235 | |
236 | socksreq[0] = 4; /* version (SOCKS4) */ |
237 | socksreq[1] = 1; /* connect */ |
238 | socksreq[2] = (unsigned char)((remote_port >> 8) & 0xff); /* PORT MSB */ |
239 | socksreq[3] = (unsigned char)(remote_port & 0xff); /* PORT LSB */ |
240 | |
241 | /* DNS resolve only for SOCKS4, not SOCKS4a */ |
242 | if(!protocol4a) { |
243 | enum resolve_t rc = |
244 | Curl_resolv(data, hostname, remote_port, FALSE, &dns); |
245 | |
246 | if(rc == CURLRESOLV_ERROR) |
247 | return CURLPX_RESOLVE_HOST; |
248 | else if(rc == CURLRESOLV_PENDING) { |
249 | sxstate(data, CONNECT_RESOLVING); |
250 | infof(data, "SOCKS4 non-blocking resolve of %s" , hostname); |
251 | return CURLPX_OK; |
252 | } |
253 | sxstate(data, CONNECT_RESOLVED); |
254 | goto CONNECT_RESOLVED; |
255 | } |
256 | |
257 | /* socks4a doesn't resolve anything locally */ |
258 | sxstate(data, CONNECT_REQ_INIT); |
259 | goto CONNECT_REQ_INIT; |
260 | |
261 | case CONNECT_RESOLVING: |
262 | /* check if we have the name resolved by now */ |
263 | dns = Curl_fetch_addr(data, hostname, (int)conn->port); |
264 | |
265 | if(dns) { |
266 | #ifdef CURLRES_ASYNCH |
267 | data->state.async.dns = dns; |
268 | data->state.async.done = TRUE; |
269 | #endif |
270 | infof(data, "Hostname '%s' was found" , hostname); |
271 | sxstate(data, CONNECT_RESOLVED); |
272 | } |
273 | else { |
274 | result = Curl_resolv_check(data, &dns); |
275 | if(!dns) { |
276 | if(result) |
277 | return CURLPX_RESOLVE_HOST; |
278 | return CURLPX_OK; |
279 | } |
280 | } |
281 | /* FALLTHROUGH */ |
282 | CONNECT_RESOLVED: |
283 | case CONNECT_RESOLVED: { |
284 | struct Curl_addrinfo *hp = NULL; |
285 | /* |
286 | * We cannot use 'hostent' as a struct that Curl_resolv() returns. It |
287 | * returns a Curl_addrinfo pointer that may not always look the same. |
288 | */ |
289 | if(dns) { |
290 | hp = dns->addr; |
291 | |
292 | /* scan for the first IPv4 address */ |
293 | while(hp && (hp->ai_family != AF_INET)) |
294 | hp = hp->ai_next; |
295 | |
296 | if(hp) { |
297 | struct sockaddr_in *saddr_in; |
298 | char buf[64]; |
299 | Curl_printable_address(hp, buf, sizeof(buf)); |
300 | |
301 | saddr_in = (struct sockaddr_in *)(void *)hp->ai_addr; |
302 | socksreq[4] = ((unsigned char *)&saddr_in->sin_addr.s_addr)[0]; |
303 | socksreq[5] = ((unsigned char *)&saddr_in->sin_addr.s_addr)[1]; |
304 | socksreq[6] = ((unsigned char *)&saddr_in->sin_addr.s_addr)[2]; |
305 | socksreq[7] = ((unsigned char *)&saddr_in->sin_addr.s_addr)[3]; |
306 | |
307 | infof(data, "SOCKS4 connect to IPv4 %s (locally resolved)" , buf); |
308 | |
309 | Curl_resolv_unlock(data, dns); /* not used anymore from now on */ |
310 | } |
311 | else |
312 | failf(data, "SOCKS4 connection to %s not supported" , hostname); |
313 | } |
314 | else |
315 | failf(data, "Failed to resolve \"%s\" for SOCKS4 connect." , |
316 | hostname); |
317 | |
318 | if(!hp) |
319 | return CURLPX_RESOLVE_HOST; |
320 | } |
321 | /* FALLTHROUGH */ |
322 | CONNECT_REQ_INIT: |
323 | case CONNECT_REQ_INIT: |
324 | /* |
325 | * This is currently not supporting "Identification Protocol (RFC1413)". |
326 | */ |
327 | socksreq[8] = 0; /* ensure empty userid is NUL-terminated */ |
328 | if(proxy_user) { |
329 | size_t plen = strlen(proxy_user); |
330 | if(plen >= (size_t)data->set.buffer_size - 8) { |
331 | failf(data, "Too long SOCKS proxy user name, can't use" ); |
332 | return CURLPX_LONG_USER; |
333 | } |
334 | /* copy the proxy name WITH trailing zero */ |
335 | memcpy(socksreq + 8, proxy_user, plen + 1); |
336 | } |
337 | |
338 | /* |
339 | * Make connection |
340 | */ |
341 | { |
342 | size_t packetsize = 9 + |
343 | strlen((char *)socksreq + 8); /* size including NUL */ |
344 | |
345 | /* If SOCKS4a, set special invalid IP address 0.0.0.x */ |
346 | if(protocol4a) { |
347 | size_t hostnamelen = 0; |
348 | socksreq[4] = 0; |
349 | socksreq[5] = 0; |
350 | socksreq[6] = 0; |
351 | socksreq[7] = 1; |
352 | /* append hostname */ |
353 | hostnamelen = strlen(hostname) + 1; /* length including NUL */ |
354 | if(hostnamelen <= 255) |
355 | strcpy((char *)socksreq + packetsize, hostname); |
356 | else { |
357 | failf(data, "SOCKS4: too long host name" ); |
358 | return CURLPX_LONG_HOSTNAME; |
359 | } |
360 | packetsize += hostnamelen; |
361 | } |
362 | sx->outp = socksreq; |
363 | sx->outstanding = packetsize; |
364 | sxstate(data, CONNECT_REQ_SENDING); |
365 | } |
366 | /* FALLTHROUGH */ |
367 | case CONNECT_REQ_SENDING: |
368 | /* Send request */ |
369 | result = Curl_write_plain(data, sockfd, (char *)sx->outp, |
370 | sx->outstanding, &written); |
371 | if(result && (CURLE_AGAIN != result)) { |
372 | failf(data, "Failed to send SOCKS4 connect request." ); |
373 | return CURLPX_SEND_CONNECT; |
374 | } |
375 | if(written != sx->outstanding) { |
376 | /* not done, remain in state */ |
377 | sx->outstanding -= written; |
378 | sx->outp += written; |
379 | return CURLPX_OK; |
380 | } |
381 | |
382 | /* done sending! */ |
383 | sx->outstanding = 8; /* receive data size */ |
384 | sx->outp = socksreq; |
385 | sxstate(data, CONNECT_SOCKS_READ); |
386 | |
387 | /* FALLTHROUGH */ |
388 | case CONNECT_SOCKS_READ: |
389 | /* Receive response */ |
390 | result = Curl_read_plain(sockfd, (char *)sx->outp, |
391 | sx->outstanding, &actualread); |
392 | if(result && (CURLE_AGAIN != result)) { |
393 | failf(data, "SOCKS4: Failed receiving connect request ack: %s" , |
394 | curl_easy_strerror(result)); |
395 | return CURLPX_RECV_CONNECT; |
396 | } |
397 | else if(!result && !actualread) { |
398 | /* connection closed */ |
399 | failf(data, "connection to proxy closed" ); |
400 | return CURLPX_CLOSED; |
401 | } |
402 | else if(actualread != sx->outstanding) { |
403 | /* remain in reading state */ |
404 | sx->outstanding -= actualread; |
405 | sx->outp += actualread; |
406 | return CURLPX_OK; |
407 | } |
408 | sxstate(data, CONNECT_DONE); |
409 | break; |
410 | default: /* lots of unused states in SOCKS4 */ |
411 | break; |
412 | } |
413 | |
414 | /* |
415 | * Response format |
416 | * |
417 | * +----+----+----+----+----+----+----+----+ |
418 | * | VN | CD | DSTPORT | DSTIP | |
419 | * +----+----+----+----+----+----+----+----+ |
420 | * # of bytes: 1 1 2 4 |
421 | * |
422 | * VN is the version of the reply code and should be 0. CD is the result |
423 | * code with one of the following values: |
424 | * |
425 | * 90: request granted |
426 | * 91: request rejected or failed |
427 | * 92: request rejected because SOCKS server cannot connect to |
428 | * identd on the client |
429 | * 93: request rejected because the client program and identd |
430 | * report different user-ids |
431 | */ |
432 | |
433 | /* wrong version ? */ |
434 | if(socksreq[0]) { |
435 | failf(data, |
436 | "SOCKS4 reply has wrong version, version should be 0." ); |
437 | return CURLPX_BAD_VERSION; |
438 | } |
439 | |
440 | /* Result */ |
441 | switch(socksreq[1]) { |
442 | case 90: |
443 | infof(data, "SOCKS4%s request granted." , protocol4a?"a" :"" ); |
444 | break; |
445 | case 91: |
446 | failf(data, |
447 | "Can't complete SOCKS4 connection to %d.%d.%d.%d:%d. (%d)" |
448 | ", request rejected or failed." , |
449 | socksreq[4], socksreq[5], socksreq[6], socksreq[7], |
450 | (((unsigned char)socksreq[2] << 8) | (unsigned char)socksreq[3]), |
451 | (unsigned char)socksreq[1]); |
452 | return CURLPX_REQUEST_FAILED; |
453 | case 92: |
454 | failf(data, |
455 | "Can't complete SOCKS4 connection to %d.%d.%d.%d:%d. (%d)" |
456 | ", request rejected because SOCKS server cannot connect to " |
457 | "identd on the client." , |
458 | socksreq[4], socksreq[5], socksreq[6], socksreq[7], |
459 | (((unsigned char)socksreq[2] << 8) | (unsigned char)socksreq[3]), |
460 | (unsigned char)socksreq[1]); |
461 | return CURLPX_IDENTD; |
462 | case 93: |
463 | failf(data, |
464 | "Can't complete SOCKS4 connection to %d.%d.%d.%d:%d. (%d)" |
465 | ", request rejected because the client program and identd " |
466 | "report different user-ids." , |
467 | socksreq[4], socksreq[5], socksreq[6], socksreq[7], |
468 | (((unsigned char)socksreq[2] << 8) | (unsigned char)socksreq[3]), |
469 | (unsigned char)socksreq[1]); |
470 | return CURLPX_IDENTD_DIFFER; |
471 | default: |
472 | failf(data, |
473 | "Can't complete SOCKS4 connection to %d.%d.%d.%d:%d. (%d)" |
474 | ", Unknown." , |
475 | socksreq[4], socksreq[5], socksreq[6], socksreq[7], |
476 | (((unsigned char)socksreq[2] << 8) | (unsigned char)socksreq[3]), |
477 | (unsigned char)socksreq[1]); |
478 | return CURLPX_UNKNOWN_FAIL; |
479 | } |
480 | |
481 | *done = TRUE; |
482 | return CURLPX_OK; /* Proxy was successful! */ |
483 | } |
484 | |
485 | /* |
486 | * This function logs in to a SOCKS5 proxy and sends the specifics to the final |
487 | * destination server. |
488 | */ |
489 | CURLproxycode Curl_SOCKS5(const char *proxy_user, |
490 | const char *proxy_password, |
491 | const char *hostname, |
492 | int remote_port, |
493 | int sockindex, |
494 | struct Curl_easy *data, |
495 | bool *done) |
496 | { |
497 | /* |
498 | According to the RFC1928, section "6. Replies". This is what a SOCK5 |
499 | replies: |
500 | |
501 | +----+-----+-------+------+----------+----------+ |
502 | |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT | |
503 | +----+-----+-------+------+----------+----------+ |
504 | | 1 | 1 | X'00' | 1 | Variable | 2 | |
505 | +----+-----+-------+------+----------+----------+ |
506 | |
507 | Where: |
508 | |
509 | o VER protocol version: X'05' |
510 | o REP Reply field: |
511 | o X'00' succeeded |
512 | */ |
513 | struct connectdata *conn = data->conn; |
514 | unsigned char *socksreq = (unsigned char *)data->state.buffer; |
515 | char dest[256] = "unknown" ; /* printable hostname:port */ |
516 | int idx; |
517 | ssize_t actualread; |
518 | ssize_t written; |
519 | CURLcode result; |
520 | curl_socket_t sockfd = conn->sock[sockindex]; |
521 | bool socks5_resolve_local = |
522 | (conn->socks_proxy.proxytype == CURLPROXY_SOCKS5) ? TRUE : FALSE; |
523 | const size_t hostname_len = strlen(hostname); |
524 | ssize_t len = 0; |
525 | const unsigned long auth = data->set.socks5auth; |
526 | bool allow_gssapi = FALSE; |
527 | struct connstate *sx = &conn->cnnct; |
528 | struct Curl_dns_entry *dns = NULL; |
529 | |
530 | if(!SOCKS_STATE(sx->state) && !*done) |
531 | sxstate(data, CONNECT_SOCKS_INIT); |
532 | |
533 | switch(sx->state) { |
534 | case CONNECT_SOCKS_INIT: |
535 | if(conn->bits.httpproxy) |
536 | infof(data, "SOCKS5: connecting to HTTP proxy %s port %d" , |
537 | hostname, remote_port); |
538 | |
539 | /* RFC1928 chapter 5 specifies max 255 chars for domain name in packet */ |
540 | if(!socks5_resolve_local && hostname_len > 255) { |
541 | infof(data, "SOCKS5: server resolving disabled for hostnames of " |
542 | "length > 255 [actual len=%zu]" , hostname_len); |
543 | socks5_resolve_local = TRUE; |
544 | } |
545 | |
546 | if(auth & ~(CURLAUTH_BASIC | CURLAUTH_GSSAPI)) |
547 | infof(data, |
548 | "warning: unsupported value passed to CURLOPT_SOCKS5_AUTH: %lu" , |
549 | auth); |
550 | if(!(auth & CURLAUTH_BASIC)) |
551 | /* disable username/password auth */ |
552 | proxy_user = NULL; |
553 | #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
554 | if(auth & CURLAUTH_GSSAPI) |
555 | allow_gssapi = TRUE; |
556 | #endif |
557 | |
558 | idx = 0; |
559 | socksreq[idx++] = 5; /* version */ |
560 | idx++; /* number of authentication methods */ |
561 | socksreq[idx++] = 0; /* no authentication */ |
562 | if(allow_gssapi) |
563 | socksreq[idx++] = 1; /* GSS-API */ |
564 | if(proxy_user) |
565 | socksreq[idx++] = 2; /* username/password */ |
566 | /* write the number of authentication methods */ |
567 | socksreq[1] = (unsigned char) (idx - 2); |
568 | |
569 | result = Curl_write_plain(data, sockfd, (char *)socksreq, idx, &written); |
570 | if(result && (CURLE_AGAIN != result)) { |
571 | failf(data, "Unable to send initial SOCKS5 request." ); |
572 | return CURLPX_SEND_CONNECT; |
573 | } |
574 | if(written != idx) { |
575 | sxstate(data, CONNECT_SOCKS_SEND); |
576 | sx->outstanding = idx - written; |
577 | sx->outp = &socksreq[written]; |
578 | return CURLPX_OK; |
579 | } |
580 | sxstate(data, CONNECT_SOCKS_READ); |
581 | goto CONNECT_SOCKS_READ_INIT; |
582 | case CONNECT_SOCKS_SEND: |
583 | result = Curl_write_plain(data, sockfd, (char *)sx->outp, |
584 | sx->outstanding, &written); |
585 | if(result && (CURLE_AGAIN != result)) { |
586 | failf(data, "Unable to send initial SOCKS5 request." ); |
587 | return CURLPX_SEND_CONNECT; |
588 | } |
589 | if(written != sx->outstanding) { |
590 | /* not done, remain in state */ |
591 | sx->outstanding -= written; |
592 | sx->outp += written; |
593 | return CURLPX_OK; |
594 | } |
595 | /* FALLTHROUGH */ |
596 | CONNECT_SOCKS_READ_INIT: |
597 | case CONNECT_SOCKS_READ_INIT: |
598 | sx->outstanding = 2; /* expect two bytes */ |
599 | sx->outp = socksreq; /* store it here */ |
600 | /* FALLTHROUGH */ |
601 | case CONNECT_SOCKS_READ: |
602 | result = Curl_read_plain(sockfd, (char *)sx->outp, |
603 | sx->outstanding, &actualread); |
604 | if(result && (CURLE_AGAIN != result)) { |
605 | failf(data, "Unable to receive initial SOCKS5 response." ); |
606 | return CURLPX_RECV_CONNECT; |
607 | } |
608 | else if(!result && !actualread) { |
609 | /* connection closed */ |
610 | failf(data, "Connection to proxy closed" ); |
611 | return CURLPX_CLOSED; |
612 | } |
613 | else if(actualread != sx->outstanding) { |
614 | /* remain in reading state */ |
615 | sx->outstanding -= actualread; |
616 | sx->outp += actualread; |
617 | return CURLPX_OK; |
618 | } |
619 | else if(socksreq[0] != 5) { |
620 | failf(data, "Received invalid version in initial SOCKS5 response." ); |
621 | return CURLPX_BAD_VERSION; |
622 | } |
623 | else if(socksreq[1] == 0) { |
624 | /* DONE! No authentication needed. Send request. */ |
625 | sxstate(data, CONNECT_REQ_INIT); |
626 | goto CONNECT_REQ_INIT; |
627 | } |
628 | else if(socksreq[1] == 2) { |
629 | /* regular name + password authentication */ |
630 | sxstate(data, CONNECT_AUTH_INIT); |
631 | goto CONNECT_AUTH_INIT; |
632 | } |
633 | #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
634 | else if(allow_gssapi && (socksreq[1] == 1)) { |
635 | sxstate(data, CONNECT_GSSAPI_INIT); |
636 | result = Curl_SOCKS5_gssapi_negotiate(sockindex, data); |
637 | if(result) { |
638 | failf(data, "Unable to negotiate SOCKS5 GSS-API context." ); |
639 | return CURLPX_GSSAPI; |
640 | } |
641 | } |
642 | #endif |
643 | else { |
644 | /* error */ |
645 | if(!allow_gssapi && (socksreq[1] == 1)) { |
646 | failf(data, |
647 | "SOCKS5 GSSAPI per-message authentication is not supported." ); |
648 | return CURLPX_GSSAPI_PERMSG; |
649 | } |
650 | else if(socksreq[1] == 255) { |
651 | failf(data, "No authentication method was acceptable." ); |
652 | return CURLPX_NO_AUTH; |
653 | } |
654 | } |
655 | failf(data, |
656 | "Undocumented SOCKS5 mode attempted to be used by server." ); |
657 | return CURLPX_UNKNOWN_MODE; |
658 | #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
659 | case CONNECT_GSSAPI_INIT: |
660 | /* GSSAPI stuff done non-blocking */ |
661 | break; |
662 | #endif |
663 | |
664 | default: /* do nothing! */ |
665 | break; |
666 | |
667 | CONNECT_AUTH_INIT: |
668 | case CONNECT_AUTH_INIT: { |
669 | /* Needs user name and password */ |
670 | size_t proxy_user_len, proxy_password_len; |
671 | if(proxy_user && proxy_password) { |
672 | proxy_user_len = strlen(proxy_user); |
673 | proxy_password_len = strlen(proxy_password); |
674 | } |
675 | else { |
676 | proxy_user_len = 0; |
677 | proxy_password_len = 0; |
678 | } |
679 | |
680 | /* username/password request looks like |
681 | * +----+------+----------+------+----------+ |
682 | * |VER | ULEN | UNAME | PLEN | PASSWD | |
683 | * +----+------+----------+------+----------+ |
684 | * | 1 | 1 | 1 to 255 | 1 | 1 to 255 | |
685 | * +----+------+----------+------+----------+ |
686 | */ |
687 | len = 0; |
688 | socksreq[len++] = 1; /* username/pw subnegotiation version */ |
689 | socksreq[len++] = (unsigned char) proxy_user_len; |
690 | if(proxy_user && proxy_user_len) { |
691 | /* the length must fit in a single byte */ |
692 | if(proxy_user_len >= 255) { |
693 | failf(data, "Excessive user name length for proxy auth" ); |
694 | return CURLPX_LONG_USER; |
695 | } |
696 | memcpy(socksreq + len, proxy_user, proxy_user_len); |
697 | } |
698 | len += proxy_user_len; |
699 | socksreq[len++] = (unsigned char) proxy_password_len; |
700 | if(proxy_password && proxy_password_len) { |
701 | /* the length must fit in a single byte */ |
702 | if(proxy_password_len > 255) { |
703 | failf(data, "Excessive password length for proxy auth" ); |
704 | return CURLPX_LONG_PASSWD; |
705 | } |
706 | memcpy(socksreq + len, proxy_password, proxy_password_len); |
707 | } |
708 | len += proxy_password_len; |
709 | sxstate(data, CONNECT_AUTH_SEND); |
710 | sx->outstanding = len; |
711 | sx->outp = socksreq; |
712 | } |
713 | /* FALLTHROUGH */ |
714 | case CONNECT_AUTH_SEND: |
715 | result = Curl_write_plain(data, sockfd, (char *)sx->outp, |
716 | sx->outstanding, &written); |
717 | if(result && (CURLE_AGAIN != result)) { |
718 | failf(data, "Failed to send SOCKS5 sub-negotiation request." ); |
719 | return CURLPX_SEND_AUTH; |
720 | } |
721 | if(sx->outstanding != written) { |
722 | /* remain in state */ |
723 | sx->outstanding -= written; |
724 | sx->outp += written; |
725 | return CURLPX_OK; |
726 | } |
727 | sx->outp = socksreq; |
728 | sx->outstanding = 2; |
729 | sxstate(data, CONNECT_AUTH_READ); |
730 | /* FALLTHROUGH */ |
731 | case CONNECT_AUTH_READ: |
732 | result = Curl_read_plain(sockfd, (char *)sx->outp, |
733 | sx->outstanding, &actualread); |
734 | if(result && (CURLE_AGAIN != result)) { |
735 | failf(data, "Unable to receive SOCKS5 sub-negotiation response." ); |
736 | return CURLPX_RECV_AUTH; |
737 | } |
738 | else if(!result && !actualread) { |
739 | /* connection closed */ |
740 | failf(data, "connection to proxy closed" ); |
741 | return CURLPX_CLOSED; |
742 | } |
743 | else if(actualread != sx->outstanding) { |
744 | /* remain in state */ |
745 | sx->outstanding -= actualread; |
746 | sx->outp += actualread; |
747 | return CURLPX_OK; |
748 | } |
749 | /* ignore the first (VER) byte */ |
750 | else if(socksreq[1]) { /* status */ |
751 | failf(data, "User was rejected by the SOCKS5 server (%d %d)." , |
752 | socksreq[0], socksreq[1]); |
753 | return CURLPX_USER_REJECTED; |
754 | } |
755 | |
756 | /* Everything is good so far, user was authenticated! */ |
757 | sxstate(data, CONNECT_REQ_INIT); |
758 | /* FALLTHROUGH */ |
759 | CONNECT_REQ_INIT: |
760 | case CONNECT_REQ_INIT: |
761 | if(socks5_resolve_local) { |
762 | enum resolve_t rc = Curl_resolv(data, hostname, remote_port, |
763 | FALSE, &dns); |
764 | |
765 | if(rc == CURLRESOLV_ERROR) |
766 | return CURLPX_RESOLVE_HOST; |
767 | |
768 | if(rc == CURLRESOLV_PENDING) { |
769 | sxstate(data, CONNECT_RESOLVING); |
770 | return CURLPX_OK; |
771 | } |
772 | sxstate(data, CONNECT_RESOLVED); |
773 | goto CONNECT_RESOLVED; |
774 | } |
775 | goto CONNECT_RESOLVE_REMOTE; |
776 | |
777 | case CONNECT_RESOLVING: |
778 | /* check if we have the name resolved by now */ |
779 | dns = Curl_fetch_addr(data, hostname, remote_port); |
780 | |
781 | if(dns) { |
782 | #ifdef CURLRES_ASYNCH |
783 | data->state.async.dns = dns; |
784 | data->state.async.done = TRUE; |
785 | #endif |
786 | infof(data, "SOCKS5: hostname '%s' found" , hostname); |
787 | } |
788 | |
789 | if(!dns) { |
790 | result = Curl_resolv_check(data, &dns); |
791 | if(!dns) { |
792 | if(result) |
793 | return CURLPX_RESOLVE_HOST; |
794 | return CURLPX_OK; |
795 | } |
796 | } |
797 | /* FALLTHROUGH */ |
798 | CONNECT_RESOLVED: |
799 | case CONNECT_RESOLVED: { |
800 | struct Curl_addrinfo *hp = NULL; |
801 | size_t destlen; |
802 | if(dns) |
803 | hp = dns->addr; |
804 | if(!hp) { |
805 | failf(data, "Failed to resolve \"%s\" for SOCKS5 connect." , |
806 | hostname); |
807 | return CURLPX_RESOLVE_HOST; |
808 | } |
809 | |
810 | Curl_printable_address(hp, dest, sizeof(dest)); |
811 | destlen = strlen(dest); |
812 | msnprintf(dest + destlen, sizeof(dest) - destlen, ":%d" , remote_port); |
813 | |
814 | len = 0; |
815 | socksreq[len++] = 5; /* version (SOCKS5) */ |
816 | socksreq[len++] = 1; /* connect */ |
817 | socksreq[len++] = 0; /* must be zero */ |
818 | if(hp->ai_family == AF_INET) { |
819 | int i; |
820 | struct sockaddr_in *saddr_in; |
821 | socksreq[len++] = 1; /* ATYP: IPv4 = 1 */ |
822 | |
823 | saddr_in = (struct sockaddr_in *)(void *)hp->ai_addr; |
824 | for(i = 0; i < 4; i++) { |
825 | socksreq[len++] = ((unsigned char *)&saddr_in->sin_addr.s_addr)[i]; |
826 | } |
827 | |
828 | infof(data, "SOCKS5 connect to IPv4 %s (locally resolved)" , dest); |
829 | } |
830 | #ifdef ENABLE_IPV6 |
831 | else if(hp->ai_family == AF_INET6) { |
832 | int i; |
833 | struct sockaddr_in6 *saddr_in6; |
834 | socksreq[len++] = 4; /* ATYP: IPv6 = 4 */ |
835 | |
836 | saddr_in6 = (struct sockaddr_in6 *)(void *)hp->ai_addr; |
837 | for(i = 0; i < 16; i++) { |
838 | socksreq[len++] = |
839 | ((unsigned char *)&saddr_in6->sin6_addr.s6_addr)[i]; |
840 | } |
841 | |
842 | infof(data, "SOCKS5 connect to IPv6 %s (locally resolved)" , dest); |
843 | } |
844 | #endif |
845 | else { |
846 | hp = NULL; /* fail! */ |
847 | failf(data, "SOCKS5 connection to %s not supported" , dest); |
848 | } |
849 | |
850 | Curl_resolv_unlock(data, dns); /* not used anymore from now on */ |
851 | goto CONNECT_REQ_SEND; |
852 | } |
853 | CONNECT_RESOLVE_REMOTE: |
854 | case CONNECT_RESOLVE_REMOTE: |
855 | /* Authentication is complete, now specify destination to the proxy */ |
856 | len = 0; |
857 | socksreq[len++] = 5; /* version (SOCKS5) */ |
858 | socksreq[len++] = 1; /* connect */ |
859 | socksreq[len++] = 0; /* must be zero */ |
860 | |
861 | if(!socks5_resolve_local) { |
862 | /* ATYP: domain name = 3, |
863 | IPv6 == 4, |
864 | IPv4 == 1 */ |
865 | unsigned char ip4[4]; |
866 | #ifdef ENABLE_IPV6 |
867 | if(conn->bits.ipv6_ip) { |
868 | char ip6[16]; |
869 | if(1 != Curl_inet_pton(AF_INET6, hostname, ip6)) |
870 | return CURLPX_BAD_ADDRESS_TYPE; |
871 | socksreq[len++] = 4; |
872 | memcpy(&socksreq[len], ip6, sizeof(ip6)); |
873 | len += sizeof(ip6); |
874 | } |
875 | else |
876 | #endif |
877 | if(1 == Curl_inet_pton(AF_INET, hostname, ip4)) { |
878 | socksreq[len++] = 1; |
879 | memcpy(&socksreq[len], ip4, sizeof(ip4)); |
880 | len += sizeof(ip4); |
881 | } |
882 | else { |
883 | socksreq[len++] = 3; |
884 | socksreq[len++] = (char) hostname_len; /* one byte address length */ |
885 | memcpy(&socksreq[len], hostname, hostname_len); /* address w/o NULL */ |
886 | len += hostname_len; |
887 | } |
888 | infof(data, "SOCKS5 connect to %s:%d (remotely resolved)" , |
889 | hostname, remote_port); |
890 | } |
891 | /* FALLTHROUGH */ |
892 | |
893 | CONNECT_REQ_SEND: |
894 | case CONNECT_REQ_SEND: |
895 | /* PORT MSB */ |
896 | socksreq[len++] = (unsigned char)((remote_port >> 8) & 0xff); |
897 | /* PORT LSB */ |
898 | socksreq[len++] = (unsigned char)(remote_port & 0xff); |
899 | |
900 | #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
901 | if(conn->socks5_gssapi_enctype) { |
902 | failf(data, "SOCKS5 GSS-API protection not yet implemented." ); |
903 | return CURLPX_GSSAPI_PROTECTION; |
904 | } |
905 | #endif |
906 | sx->outp = socksreq; |
907 | sx->outstanding = len; |
908 | sxstate(data, CONNECT_REQ_SENDING); |
909 | /* FALLTHROUGH */ |
910 | case CONNECT_REQ_SENDING: |
911 | result = Curl_write_plain(data, sockfd, (char *)sx->outp, |
912 | sx->outstanding, &written); |
913 | if(result && (CURLE_AGAIN != result)) { |
914 | failf(data, "Failed to send SOCKS5 connect request." ); |
915 | return CURLPX_SEND_REQUEST; |
916 | } |
917 | if(sx->outstanding != written) { |
918 | /* remain in state */ |
919 | sx->outstanding -= written; |
920 | sx->outp += written; |
921 | return CURLPX_OK; |
922 | } |
923 | #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
924 | if(conn->socks5_gssapi_enctype) { |
925 | failf(data, "SOCKS5 GSS-API protection not yet implemented." ); |
926 | return CURLPX_GSSAPI_PROTECTION; |
927 | } |
928 | #endif |
929 | sx->outstanding = 10; /* minimum packet size is 10 */ |
930 | sx->outp = socksreq; |
931 | sxstate(data, CONNECT_REQ_READ); |
932 | /* FALLTHROUGH */ |
933 | case CONNECT_REQ_READ: |
934 | result = Curl_read_plain(sockfd, (char *)sx->outp, |
935 | sx->outstanding, &actualread); |
936 | if(result && (CURLE_AGAIN != result)) { |
937 | failf(data, "Failed to receive SOCKS5 connect request ack." ); |
938 | return CURLPX_RECV_REQACK; |
939 | } |
940 | else if(!result && !actualread) { |
941 | /* connection closed */ |
942 | failf(data, "connection to proxy closed" ); |
943 | return CURLPX_CLOSED; |
944 | } |
945 | else if(actualread != sx->outstanding) { |
946 | /* remain in state */ |
947 | sx->outstanding -= actualread; |
948 | sx->outp += actualread; |
949 | return CURLPX_OK; |
950 | } |
951 | |
952 | if(socksreq[0] != 5) { /* version */ |
953 | failf(data, |
954 | "SOCKS5 reply has wrong version, version should be 5." ); |
955 | return CURLPX_BAD_VERSION; |
956 | } |
957 | else if(socksreq[1]) { /* Anything besides 0 is an error */ |
958 | CURLproxycode rc = CURLPX_REPLY_UNASSIGNED; |
959 | int code = socksreq[1]; |
960 | failf(data, "Can't complete SOCKS5 connection to %s. (%d)" , |
961 | hostname, (unsigned char)socksreq[1]); |
962 | if(code < 9) { |
963 | /* RFC 1928 section 6 lists: */ |
964 | static const CURLproxycode lookup[] = { |
965 | CURLPX_OK, |
966 | CURLPX_REPLY_GENERAL_SERVER_FAILURE, |
967 | CURLPX_REPLY_NOT_ALLOWED, |
968 | CURLPX_REPLY_NETWORK_UNREACHABLE, |
969 | CURLPX_REPLY_HOST_UNREACHABLE, |
970 | CURLPX_REPLY_CONNECTION_REFUSED, |
971 | CURLPX_REPLY_TTL_EXPIRED, |
972 | CURLPX_REPLY_COMMAND_NOT_SUPPORTED, |
973 | CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED, |
974 | }; |
975 | rc = lookup[code]; |
976 | } |
977 | return rc; |
978 | } |
979 | |
980 | /* Fix: in general, returned BND.ADDR is variable length parameter by RFC |
981 | 1928, so the reply packet should be read until the end to avoid errors |
982 | at subsequent protocol level. |
983 | |
984 | +----+-----+-------+------+----------+----------+ |
985 | |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT | |
986 | +----+-----+-------+------+----------+----------+ |
987 | | 1 | 1 | X'00' | 1 | Variable | 2 | |
988 | +----+-----+-------+------+----------+----------+ |
989 | |
990 | ATYP: |
991 | o IP v4 address: X'01', BND.ADDR = 4 byte |
992 | o domain name: X'03', BND.ADDR = [ 1 byte length, string ] |
993 | o IP v6 address: X'04', BND.ADDR = 16 byte |
994 | */ |
995 | |
996 | /* Calculate real packet size */ |
997 | if(socksreq[3] == 3) { |
998 | /* domain name */ |
999 | int addrlen = (int) socksreq[4]; |
1000 | len = 5 + addrlen + 2; |
1001 | } |
1002 | else if(socksreq[3] == 4) { |
1003 | /* IPv6 */ |
1004 | len = 4 + 16 + 2; |
1005 | } |
1006 | else if(socksreq[3] == 1) { |
1007 | len = 4 + 4 + 2; |
1008 | } |
1009 | else { |
1010 | failf(data, "SOCKS5 reply has wrong address type." ); |
1011 | return CURLPX_BAD_ADDRESS_TYPE; |
1012 | } |
1013 | |
1014 | /* At this point we already read first 10 bytes */ |
1015 | #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
1016 | if(!conn->socks5_gssapi_enctype) { |
1017 | /* decrypt_gssapi_blockread already read the whole packet */ |
1018 | #endif |
1019 | if(len > 10) { |
1020 | sx->outstanding = len - 10; /* get the rest */ |
1021 | sx->outp = &socksreq[10]; |
1022 | sxstate(data, CONNECT_REQ_READ_MORE); |
1023 | } |
1024 | else { |
1025 | sxstate(data, CONNECT_DONE); |
1026 | break; |
1027 | } |
1028 | #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
1029 | } |
1030 | #endif |
1031 | /* FALLTHROUGH */ |
1032 | case CONNECT_REQ_READ_MORE: |
1033 | result = Curl_read_plain(sockfd, (char *)sx->outp, |
1034 | sx->outstanding, &actualread); |
1035 | if(result && (CURLE_AGAIN != result)) { |
1036 | failf(data, "Failed to receive SOCKS5 connect request ack." ); |
1037 | return CURLPX_RECV_ADDRESS; |
1038 | } |
1039 | else if(!result && !actualread) { |
1040 | /* connection closed */ |
1041 | failf(data, "connection to proxy closed" ); |
1042 | return CURLPX_CLOSED; |
1043 | } |
1044 | else if(actualread != sx->outstanding) { |
1045 | /* remain in state */ |
1046 | sx->outstanding -= actualread; |
1047 | sx->outp += actualread; |
1048 | return CURLPX_OK; |
1049 | } |
1050 | sxstate(data, CONNECT_DONE); |
1051 | } |
1052 | infof(data, "SOCKS5 request granted." ); |
1053 | |
1054 | *done = TRUE; |
1055 | return CURLPX_OK; /* Proxy was successful! */ |
1056 | } |
1057 | |
1058 | #endif /* CURL_DISABLE_PROXY */ |
1059 | |