Add timeouts to 'tinc join'
[tinc] / src / proxy.c
1 #include "system.h"
2
3 #include "logger.h"
4 #include "proxy.h"
5
6 typedef enum socks5_auth_method_t {
7         AUTH_ANONYMOUS = 0,
8         AUTH_PASSWORD = 2,
9         AUTH_FAILED = 0xFF,
10 } socks5_auth_method_t;
11
12 // SOCKS 4 constants (https://en.wikipedia.org/wiki/SOCKS#SOCKS4)
13 static const uint8_t SOCKS4_CMD_CONN = 1;
14 static const uint8_t SOCKS4_REPLY_VERSION = 0;
15 static const uint8_t SOCKS4_STATUS_OK = 0x5A;
16 static const uint8_t SOCKS4_VERSION = 4;
17
18 // SOCKS 5 constants (https://en.wikipedia.org/wiki/SOCKS#SOCKS5)
19 typedef enum socks5_addr_type_t {
20         SOCKS5_IPV4 = 1,
21         SOCKS5_IPV6 = 4,
22 } socks5_addr_type_t;
23
24 static const uint8_t SOCKS5_AUTH_METHOD_NONE = 0;
25 static const uint8_t SOCKS5_AUTH_METHOD_PASSWORD = 2;
26 static const uint8_t SOCKS5_AUTH_OK = 0;
27 static const uint8_t SOCKS5_AUTH_VERSION = 1;
28 static const uint8_t SOCKS5_COMMAND_CONN = 1;
29 static const uint8_t SOCKS5_STATUS_OK = 0;
30 static const uint8_t SOCKS5_VERSION = 5;
31
32 static void log_proxy_grant(bool granted) {
33         if(granted) {
34                 logger(DEBUG_CONNECTIONS, LOG_DEBUG, "Proxy request granted");
35         } else {
36                 logger(DEBUG_CONNECTIONS, LOG_ERR, "Proxy request rejected");
37         }
38 }
39
40 static void log_short_response(void) {
41         logger(DEBUG_CONNECTIONS, LOG_ERR, "Received short response from proxy");
42 }
43
44 static bool check_socks4_resp(const socks4_response_t *resp, size_t len) {
45         if(len < sizeof(socks4_response_t)) {
46                 log_short_response();
47                 return false;
48         }
49
50         if(resp->version != SOCKS4_REPLY_VERSION) {
51                 logger(DEBUG_CONNECTIONS, LOG_ERR, "Bad response from SOCKS4 proxy");
52                 return false;
53         }
54
55         bool granted = resp->status == SOCKS4_STATUS_OK;
56         log_proxy_grant(granted);
57         return granted;
58 }
59
60 static bool socks5_check_result(const socks5_conn_resp_t *re, size_t len) {
61         size_t addrlen;
62
63         switch((socks5_addr_type_t)re->addr_type) {
64         case SOCKS5_IPV4:
65                 addrlen = sizeof(socks5_ipv4_t);
66                 break;
67
68         case SOCKS5_IPV6:
69                 addrlen = sizeof(socks5_ipv6_t);
70                 break;
71
72         default:
73                 logger(DEBUG_CONNECTIONS, LOG_ERR, "Unsupported address type 0x%x from proxy server", re->addr_type);
74                 return false;
75         }
76
77         if(len < addrlen) {
78                 logger(DEBUG_CONNECTIONS, LOG_ERR, "Received short address from proxy server");
79                 return false;
80         }
81
82         if(re->socks_version != SOCKS5_VERSION) {
83                 logger(DEBUG_CONNECTIONS, LOG_ERR, "Invalid response from proxy server");
84                 return false;
85         }
86
87         bool granted = re->conn_status == SOCKS5_STATUS_OK;
88         log_proxy_grant(granted);
89         return granted;
90 }
91
92 static bool check_socks5_resp(const socks5_resp_t *resp, size_t len) {
93         if(len < sizeof(socks5_server_choice_t)) {
94                 log_short_response();
95                 return false;
96         }
97
98         len -= sizeof(socks5_server_choice_t);
99
100         if(resp->choice.socks_version != SOCKS5_VERSION) {
101                 logger(DEBUG_CONNECTIONS, LOG_ERR, "Invalid response from proxy server");
102                 return false;
103         }
104
105         switch((socks5_auth_method_t) resp->choice.auth_method) {
106         case AUTH_ANONYMOUS:
107                 if(len < sizeof(socks5_conn_resp_t)) {
108                         log_short_response();
109                         return false;
110                 } else {
111                         return socks5_check_result(&resp->anon, len - sizeof(socks5_conn_resp_t));
112                 }
113
114         case AUTH_PASSWORD: {
115                 size_t header_len = sizeof(socks5_auth_status_t) + sizeof(socks5_conn_resp_t);
116
117                 if(len < header_len) {
118                         log_short_response();
119                         return false;
120                 }
121
122                 if(resp->pass.status.auth_version != SOCKS5_AUTH_VERSION) {
123                         logger(DEBUG_CONNECTIONS, LOG_ERR, "Invalid proxy authentication protocol version");
124                         return false;
125                 }
126
127                 if(resp->pass.status.auth_status != SOCKS5_AUTH_OK) {
128                         logger(DEBUG_CONNECTIONS, LOG_ERR, "Proxy authentication failed");
129                         return false;
130                 }
131
132                 return socks5_check_result(&resp->pass.resp, len - header_len);
133         }
134
135         case AUTH_FAILED:
136                 logger(DEBUG_CONNECTIONS, LOG_ERR, "Proxy request rejected: unsuitable authentication method");
137                 return false;
138
139         default:
140                 logger(DEBUG_CONNECTIONS, LOG_ERR, "Unsupported authentication method");
141                 return false;
142         }
143 }
144
145 bool check_socks_resp(proxytype_t type, const void *buf, size_t len) {
146         if(type == PROXY_SOCKS4) {
147                 return check_socks4_resp(buf, len);
148         } else if(type == PROXY_SOCKS5) {
149                 return check_socks5_resp(buf, len);
150         } else {
151                 return false;
152         }
153 }
154
155 static size_t create_socks4_req(socks4_request_t *req, const sockaddr_t *sa) {
156         if(sa->sa.sa_family != AF_INET) {
157                 logger(DEBUG_ALWAYS, LOG_ERR, "Cannot connect to an IPv6 host through a SOCKS 4 proxy!");
158                 return 0;
159         }
160
161         req->version = SOCKS4_VERSION;
162         req->command = SOCKS4_CMD_CONN;
163         req->dstport = sa->in.sin_port;
164         req->dstip = sa->in.sin_addr;
165
166         if(proxyuser) {
167                 strcpy(req->id, proxyuser);
168         } else {
169                 req->id[0] = '\0';
170         }
171
172         return sizeof(socks4_response_t);
173 }
174
175 static size_t create_socks5_req(void *buf, const sockaddr_t *sa) {
176         uint16_t family = sa->sa.sa_family;
177
178         if(family != AF_INET && family != AF_INET6) {
179                 logger(DEBUG_ALWAYS, LOG_ERR, "Address family %x not supported for SOCKS 5 proxies!", family);
180                 return 0;
181         }
182
183         socks5_greet_t *req = buf;
184         req->version = SOCKS5_VERSION;
185         req->nmethods = 1; // only one auth method is supported
186
187         size_t resplen = sizeof(socks5_server_choice_t);
188         uint8_t *auth = (uint8_t *)buf + sizeof(socks5_greet_t);
189
190         if(proxyuser && proxypass) {
191                 req->authmethod = SOCKS5_AUTH_METHOD_PASSWORD;
192
193                 // field  | VER | IDLEN |  ID   | PWLEN |   PW  |
194                 // bytes  |  1  |   1   | 1-255 |   1   | 1-255 |
195
196                 // Assign the first field (auth protocol version)
197                 *auth++ = SOCKS5_AUTH_VERSION;
198
199                 size_t userlen = strlen(proxyuser);
200                 size_t passlen = strlen(proxypass);
201
202                 // Assign the username length, and copy the username
203                 *auth++ = userlen;
204                 memcpy(auth, proxyuser, userlen);
205                 auth += userlen;
206
207                 // Do the same for password
208                 *auth++ = passlen;
209                 memcpy(auth, proxypass, passlen);
210                 auth += passlen;
211
212                 resplen += sizeof(socks5_auth_status_t);
213         } else {
214                 req->authmethod = SOCKS5_AUTH_METHOD_NONE;
215         }
216
217         socks5_conn_req_t *conn = (socks5_conn_req_t *) auth;
218         conn->header.version = SOCKS5_VERSION;
219         conn->header.command = SOCKS5_COMMAND_CONN;
220         conn->header.reserved = 0;
221
222         resplen += sizeof(socks5_conn_resp_t);
223
224         if(family == AF_INET) {
225                 conn->header.addr_type = SOCKS5_IPV4;
226                 conn->dst.ipv4.addr = sa->in.sin_addr;
227                 conn->dst.ipv4.port = sa->in.sin_port;
228                 resplen += sizeof(socks5_ipv4_t);
229         } else {
230                 conn->header.addr_type = SOCKS5_IPV6;
231                 conn->dst.ipv6.addr = sa->in6.sin6_addr;
232                 conn->dst.ipv6.port = sa->in6.sin6_port;
233                 resplen += sizeof(socks5_ipv6_t);
234         }
235
236         return resplen;
237 }
238
239 size_t socks_req_len(proxytype_t type, const sockaddr_t *sa) {
240         uint16_t family = sa->sa.sa_family;
241
242         if(type == PROXY_SOCKS4) {
243                 if(family != AF_INET) {
244                         logger(DEBUG_CONNECTIONS, LOG_ERR, "SOCKS 4 only supports IPv4 addresses");
245                         return 0;
246                 }
247
248                 size_t userlen_size = 1;
249                 size_t userlen = proxyuser ? strlen(proxyuser) : 0;
250                 return sizeof(socks4_request_t) + userlen_size + userlen;
251         }
252
253         if(type == PROXY_SOCKS5) {
254                 if(family != AF_INET && family != AF_INET6) {
255                         logger(DEBUG_CONNECTIONS, LOG_ERR, "SOCKS 5 only supports IPv4 and IPv6");
256                         return 0;
257                 }
258
259                 size_t len = sizeof(socks5_greet_t) +
260                              sizeof(socks5_conn_hdr_t) +
261                              (family == AF_INET
262                               ? sizeof(socks5_ipv4_t)
263                               : sizeof(socks5_ipv6_t));
264
265                 if(proxyuser && proxypass) {
266                         // version, userlen, user, passlen, pass
267                         len += 1 + 1 + strlen(proxyuser) + 1 + strlen(proxypass);
268                 }
269
270                 return len;
271         }
272
273         logger(DEBUG_CONNECTIONS, LOG_ERR, "Bad proxy type 0x%x", type);
274         return 0;
275 }
276
277 size_t create_socks_req(proxytype_t type, void *buf, const sockaddr_t *sa) {
278         if(type == PROXY_SOCKS4) {
279                 return create_socks4_req(buf, sa);
280         } else if(type == PROXY_SOCKS5) {
281                 return create_socks5_req(buf, sa);
282         } else {
283                 abort();
284         }
285 }