ext_orport.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659
  1. /* Copyright (c) 2012-2017, The Tor Project, Inc. */
  2. /* See LICENSE for licensing information */
  3. /**
  4. * \file ext_orport.c
  5. * \brief Code implementing the Extended ORPort.
  6. *
  7. * The Extended ORPort interface is used by pluggable transports to
  8. * communicate additional information to a Tor bridge, including
  9. * address information. For more information on this interface,
  10. * see pt-spec.txt in torspec.git.
  11. *
  12. * There is no separate structure for extended ORPort connections; they use
  13. * or_connection_t objects, and share most of their implementation with
  14. * connection_or.c. Once the handshake is done, an extended ORPort connection
  15. * turns into a regular OR connection, using connection_ext_or_transition().
  16. */
  17. #define EXT_ORPORT_PRIVATE
  18. #include "or.h"
  19. #include "connection.h"
  20. #include "connection_or.h"
  21. #include "ext_orport.h"
  22. #include "control.h"
  23. #include "config.h"
  24. #include "main.h"
  25. #include "proto_ext_or.h"
  26. #include "util.h"
  27. /** Allocate and return a structure capable of holding an Extended
  28. * ORPort message of body length <b>len</b>. */
  29. ext_or_cmd_t *
  30. ext_or_cmd_new(uint16_t len)
  31. {
  32. size_t size = offsetof(ext_or_cmd_t, body) + len;
  33. ext_or_cmd_t *cmd = tor_malloc(size);
  34. cmd->len = len;
  35. return cmd;
  36. }
  37. /** Deallocate the Extended ORPort message in <b>cmd</b>. */
  38. void
  39. ext_or_cmd_free_(ext_or_cmd_t *cmd)
  40. {
  41. tor_free(cmd);
  42. }
  43. /** Get an Extended ORPort message from <b>conn</b>, and place it in
  44. * <b>out</b>. Return -1 on fail, 0 if we need more data, and 1 if we
  45. * successfully extracted an Extended ORPort command from the
  46. * buffer. */
  47. static int
  48. connection_fetch_ext_or_cmd_from_buf(connection_t *conn, ext_or_cmd_t **out)
  49. {
  50. return fetch_ext_or_command_from_buf(conn->inbuf, out);
  51. }
  52. /** Write an Extended ORPort message to <b>conn</b>. Use
  53. * <b>command</b> as the command type, <b>bodylen</b> as the body
  54. * length, and <b>body</b>, if it's present, as the body of the
  55. * message. */
  56. STATIC int
  57. connection_write_ext_or_command(connection_t *conn,
  58. uint16_t command,
  59. const char *body,
  60. size_t bodylen)
  61. {
  62. char header[4];
  63. if (bodylen > UINT16_MAX)
  64. return -1;
  65. set_uint16(header, htons(command));
  66. set_uint16(header+2, htons(bodylen));
  67. connection_buf_add(header, 4, conn);
  68. if (bodylen) {
  69. tor_assert(body);
  70. connection_buf_add(body, bodylen, conn);
  71. }
  72. return 0;
  73. }
  74. /** Transition from an Extended ORPort which accepts Extended ORPort
  75. * messages, to an Extended ORport which accepts OR traffic. */
  76. static void
  77. connection_ext_or_transition(or_connection_t *conn)
  78. {
  79. tor_assert(conn->base_.type == CONN_TYPE_EXT_OR);
  80. conn->base_.type = CONN_TYPE_OR;
  81. TO_CONN(conn)->state = 0; // set the state to a neutral value
  82. control_event_or_conn_status(conn, OR_CONN_EVENT_NEW, 0);
  83. connection_tls_start_handshake(conn, 1);
  84. }
  85. /** Length of authentication cookie. */
  86. #define EXT_OR_PORT_AUTH_COOKIE_LEN 32
  87. /** Length of the header of the cookie file. */
  88. #define EXT_OR_PORT_AUTH_COOKIE_HEADER_LEN 32
  89. /** Static cookie file header. */
  90. #define EXT_OR_PORT_AUTH_COOKIE_HEADER "! Extended ORPort Auth Cookie !\x0a"
  91. /** Length of safe-cookie protocol hashes. */
  92. #define EXT_OR_PORT_AUTH_HASH_LEN DIGEST256_LEN
  93. /** Length of safe-cookie protocol nonces. */
  94. #define EXT_OR_PORT_AUTH_NONCE_LEN 32
  95. /** Safe-cookie protocol constants. */
  96. #define EXT_OR_PORT_AUTH_SERVER_TO_CLIENT_CONST \
  97. "ExtORPort authentication server-to-client hash"
  98. #define EXT_OR_PORT_AUTH_CLIENT_TO_SERVER_CONST \
  99. "ExtORPort authentication client-to-server hash"
  100. /* Code to indicate cookie authentication */
  101. #define EXT_OR_AUTHTYPE_SAFECOOKIE 0x01
  102. /** If true, we've set ext_or_auth_cookie to a secret code and stored
  103. * it to disk. */
  104. STATIC int ext_or_auth_cookie_is_set = 0;
  105. /** If ext_or_auth_cookie_is_set, a secret cookie that we've stored to disk
  106. * and which we're using to authenticate controllers. (If the controller can
  107. * read it off disk, it has permission to connect.) */
  108. STATIC uint8_t *ext_or_auth_cookie = NULL;
  109. /** Helper: Return a newly allocated string containing a path to the
  110. * file where we store our authentication cookie. */
  111. char *
  112. get_ext_or_auth_cookie_file_name(void)
  113. {
  114. const or_options_t *options = get_options();
  115. if (options->ExtORPortCookieAuthFile &&
  116. strlen(options->ExtORPortCookieAuthFile)) {
  117. return tor_strdup(options->ExtORPortCookieAuthFile);
  118. } else {
  119. return get_datadir_fname("extended_orport_auth_cookie");
  120. }
  121. }
  122. /* Initialize the cookie-based authentication system of the
  123. * Extended ORPort. If <b>is_enabled</b> is 0, then disable the cookie
  124. * authentication system. */
  125. int
  126. init_ext_or_cookie_authentication(int is_enabled)
  127. {
  128. char *fname = NULL;
  129. int retval;
  130. if (!is_enabled) {
  131. ext_or_auth_cookie_is_set = 0;
  132. return 0;
  133. }
  134. fname = get_ext_or_auth_cookie_file_name();
  135. retval = init_cookie_authentication(fname, EXT_OR_PORT_AUTH_COOKIE_HEADER,
  136. EXT_OR_PORT_AUTH_COOKIE_HEADER_LEN,
  137. get_options()->ExtORPortCookieAuthFileGroupReadable,
  138. &ext_or_auth_cookie,
  139. &ext_or_auth_cookie_is_set);
  140. tor_free(fname);
  141. return retval;
  142. }
  143. /** Read data from <b>conn</b> and see if the client sent us the
  144. * authentication type that they prefer to use in this session.
  145. *
  146. * Return -1 if we received corrupted data or if we don't support the
  147. * authentication type. Return 0 if we need more data in
  148. * <b>conn</b>. Return 1 if the authentication type negotiation was
  149. * successful. */
  150. static int
  151. connection_ext_or_auth_neg_auth_type(connection_t *conn)
  152. {
  153. char authtype[1] = {0};
  154. if (connection_get_inbuf_len(conn) < 1)
  155. return 0;
  156. if (connection_buf_get_bytes(authtype, 1, conn) < 0)
  157. return -1;
  158. log_debug(LD_GENERAL, "Client wants us to use %d auth type", authtype[0]);
  159. if (authtype[0] != EXT_OR_AUTHTYPE_SAFECOOKIE) {
  160. /* '1' is the only auth type supported atm */
  161. return -1;
  162. }
  163. conn->state = EXT_OR_CONN_STATE_AUTH_WAIT_CLIENT_NONCE;
  164. return 1;
  165. }
  166. /* DOCDOC */
  167. STATIC int
  168. handle_client_auth_nonce(const char *client_nonce, size_t client_nonce_len,
  169. char **client_hash_out,
  170. char **reply_out, size_t *reply_len_out)
  171. {
  172. char server_hash[EXT_OR_PORT_AUTH_HASH_LEN] = {0};
  173. char server_nonce[EXT_OR_PORT_AUTH_NONCE_LEN] = {0};
  174. char *reply;
  175. size_t reply_len;
  176. if (client_nonce_len != EXT_OR_PORT_AUTH_NONCE_LEN)
  177. return -1;
  178. /* Get our nonce */
  179. crypto_rand(server_nonce, EXT_OR_PORT_AUTH_NONCE_LEN);
  180. { /* set up macs */
  181. size_t hmac_s_msg_len = strlen(EXT_OR_PORT_AUTH_SERVER_TO_CLIENT_CONST) +
  182. 2*EXT_OR_PORT_AUTH_NONCE_LEN;
  183. size_t hmac_c_msg_len = strlen(EXT_OR_PORT_AUTH_CLIENT_TO_SERVER_CONST) +
  184. 2*EXT_OR_PORT_AUTH_NONCE_LEN;
  185. char *hmac_s_msg = tor_malloc_zero(hmac_s_msg_len);
  186. char *hmac_c_msg = tor_malloc_zero(hmac_c_msg_len);
  187. char *correct_client_hash = tor_malloc_zero(EXT_OR_PORT_AUTH_HASH_LEN);
  188. memcpy(hmac_s_msg,
  189. EXT_OR_PORT_AUTH_SERVER_TO_CLIENT_CONST,
  190. strlen(EXT_OR_PORT_AUTH_SERVER_TO_CLIENT_CONST));
  191. memcpy(hmac_s_msg + strlen(EXT_OR_PORT_AUTH_SERVER_TO_CLIENT_CONST),
  192. client_nonce, EXT_OR_PORT_AUTH_NONCE_LEN);
  193. memcpy(hmac_s_msg + strlen(EXT_OR_PORT_AUTH_SERVER_TO_CLIENT_CONST) +
  194. EXT_OR_PORT_AUTH_NONCE_LEN,
  195. server_nonce, EXT_OR_PORT_AUTH_NONCE_LEN);
  196. memcpy(hmac_c_msg,
  197. EXT_OR_PORT_AUTH_CLIENT_TO_SERVER_CONST,
  198. strlen(EXT_OR_PORT_AUTH_CLIENT_TO_SERVER_CONST));
  199. memcpy(hmac_c_msg + strlen(EXT_OR_PORT_AUTH_CLIENT_TO_SERVER_CONST),
  200. client_nonce, EXT_OR_PORT_AUTH_NONCE_LEN);
  201. memcpy(hmac_c_msg + strlen(EXT_OR_PORT_AUTH_CLIENT_TO_SERVER_CONST) +
  202. EXT_OR_PORT_AUTH_NONCE_LEN,
  203. server_nonce, EXT_OR_PORT_AUTH_NONCE_LEN);
  204. crypto_hmac_sha256(server_hash,
  205. (char*)ext_or_auth_cookie,
  206. EXT_OR_PORT_AUTH_COOKIE_LEN,
  207. hmac_s_msg,
  208. hmac_s_msg_len);
  209. crypto_hmac_sha256(correct_client_hash,
  210. (char*)ext_or_auth_cookie,
  211. EXT_OR_PORT_AUTH_COOKIE_LEN,
  212. hmac_c_msg,
  213. hmac_c_msg_len);
  214. /* Store the client hash we generated. We will need to compare it
  215. with the hash sent by the client. */
  216. *client_hash_out = correct_client_hash;
  217. memwipe(hmac_s_msg, 0, hmac_s_msg_len);
  218. memwipe(hmac_c_msg, 0, hmac_c_msg_len);
  219. tor_free(hmac_s_msg);
  220. tor_free(hmac_c_msg);
  221. }
  222. { /* debug logging */ /* XXX disable this codepath if not logging on debug?*/
  223. char server_hash_encoded[(2*EXT_OR_PORT_AUTH_HASH_LEN) + 1];
  224. char server_nonce_encoded[(2*EXT_OR_PORT_AUTH_NONCE_LEN) + 1];
  225. char client_nonce_encoded[(2*EXT_OR_PORT_AUTH_NONCE_LEN) + 1];
  226. base16_encode(server_hash_encoded, sizeof(server_hash_encoded),
  227. server_hash, sizeof(server_hash));
  228. base16_encode(server_nonce_encoded, sizeof(server_nonce_encoded),
  229. server_nonce, sizeof(server_nonce));
  230. base16_encode(client_nonce_encoded, sizeof(client_nonce_encoded),
  231. client_nonce, EXT_OR_PORT_AUTH_NONCE_LEN);
  232. log_debug(LD_GENERAL,
  233. "server_hash: '%s'\nserver_nonce: '%s'\nclient_nonce: '%s'",
  234. server_hash_encoded, server_nonce_encoded, client_nonce_encoded);
  235. memwipe(server_hash_encoded, 0, sizeof(server_hash_encoded));
  236. memwipe(server_nonce_encoded, 0, sizeof(server_nonce_encoded));
  237. memwipe(client_nonce_encoded, 0, sizeof(client_nonce_encoded));
  238. }
  239. { /* write reply: (server_hash, server_nonce) */
  240. reply_len = EXT_OR_PORT_AUTH_COOKIE_LEN+EXT_OR_PORT_AUTH_NONCE_LEN;
  241. reply = tor_malloc_zero(reply_len);
  242. memcpy(reply, server_hash, EXT_OR_PORT_AUTH_HASH_LEN);
  243. memcpy(reply + EXT_OR_PORT_AUTH_HASH_LEN, server_nonce,
  244. EXT_OR_PORT_AUTH_NONCE_LEN);
  245. }
  246. *reply_out = reply;
  247. *reply_len_out = reply_len;
  248. return 0;
  249. }
  250. /** Read the client's nonce out of <b>conn</b>, setup the safe-cookie
  251. * crypto, and then send our own hash and nonce to the client
  252. *
  253. * Return -1 if there was an error; return 0 if we need more data in
  254. * <b>conn</b>, and return 1 if we successfully retrieved the
  255. * client's nonce and sent our own. */
  256. static int
  257. connection_ext_or_auth_handle_client_nonce(connection_t *conn)
  258. {
  259. char client_nonce[EXT_OR_PORT_AUTH_NONCE_LEN];
  260. char *reply=NULL;
  261. size_t reply_len=0;
  262. if (!ext_or_auth_cookie_is_set) { /* this should not happen */
  263. log_warn(LD_BUG, "Extended ORPort authentication cookie was not set. "
  264. "That's weird since we should have done that on startup. "
  265. "This might be a Tor bug, please file a bug report. ");
  266. return -1;
  267. }
  268. if (connection_get_inbuf_len(conn) < EXT_OR_PORT_AUTH_NONCE_LEN)
  269. return 0;
  270. if (connection_buf_get_bytes(client_nonce,
  271. EXT_OR_PORT_AUTH_NONCE_LEN, conn) < 0)
  272. return -1;
  273. /* We extract the ClientNonce from the received data, and use it to
  274. calculate ServerHash and ServerNonce according to proposal 217.
  275. We also calculate our own ClientHash value and save it in the
  276. connection state. We validate it later against the ClientHash
  277. sent by the client. */
  278. if (handle_client_auth_nonce(client_nonce, sizeof(client_nonce),
  279. &TO_OR_CONN(conn)->ext_or_auth_correct_client_hash,
  280. &reply, &reply_len) < 0)
  281. return -1;
  282. connection_buf_add(reply, reply_len, conn);
  283. memwipe(reply, 0, reply_len);
  284. tor_free(reply);
  285. log_debug(LD_GENERAL, "Got client nonce, and sent our own nonce and hash.");
  286. conn->state = EXT_OR_CONN_STATE_AUTH_WAIT_CLIENT_HASH;
  287. return 1;
  288. }
  289. #define connection_ext_or_auth_send_result_success(c) \
  290. connection_ext_or_auth_send_result(c, 1)
  291. #define connection_ext_or_auth_send_result_fail(c) \
  292. connection_ext_or_auth_send_result(c, 0)
  293. /** Send authentication results to <b>conn</b>. Successful results if
  294. * <b>success</b> is set; failure results otherwise. */
  295. static void
  296. connection_ext_or_auth_send_result(connection_t *conn, int success)
  297. {
  298. if (success)
  299. connection_buf_add("\x01", 1, conn);
  300. else
  301. connection_buf_add("\x00", 1, conn);
  302. }
  303. /** Receive the client's hash from <b>conn</b>, validate that it's
  304. * correct, and then send the authentication results to the client.
  305. *
  306. * Return -1 if there was an error during validation; return 0 if we
  307. * need more data in <b>conn</b>, and return 1 if we successfully
  308. * validated the client's hash and sent a happy authentication
  309. * result. */
  310. static int
  311. connection_ext_or_auth_handle_client_hash(connection_t *conn)
  312. {
  313. char provided_client_hash[EXT_OR_PORT_AUTH_HASH_LEN] = {0};
  314. if (connection_get_inbuf_len(conn) < EXT_OR_PORT_AUTH_HASH_LEN)
  315. return 0;
  316. if (connection_buf_get_bytes(provided_client_hash,
  317. EXT_OR_PORT_AUTH_HASH_LEN, conn) < 0)
  318. return -1;
  319. if (tor_memneq(TO_OR_CONN(conn)->ext_or_auth_correct_client_hash,
  320. provided_client_hash, EXT_OR_PORT_AUTH_HASH_LEN)) {
  321. log_warn(LD_GENERAL, "Incorrect client hash. Authentication failed.");
  322. connection_ext_or_auth_send_result_fail(conn);
  323. return -1;
  324. }
  325. log_debug(LD_GENERAL, "Got client's hash and it was legit.");
  326. /* send positive auth result */
  327. connection_ext_or_auth_send_result_success(conn);
  328. conn->state = EXT_OR_CONN_STATE_OPEN;
  329. return 1;
  330. }
  331. /** Handle data from <b>or_conn</b> received on Extended ORPort.
  332. * Return -1 on error. 0 on unsufficient data. 1 on correct. */
  333. static int
  334. connection_ext_or_auth_process_inbuf(or_connection_t *or_conn)
  335. {
  336. connection_t *conn = TO_CONN(or_conn);
  337. /* State transitions of the Extended ORPort authentication protocol:
  338. EXT_OR_CONN_STATE_AUTH_WAIT_AUTH_TYPE (start state) ->
  339. EXT_OR_CONN_STATE_AUTH_WAIT_CLIENT_NONCE ->
  340. EXT_OR_CONN_STATE_AUTH_WAIT_CLIENT_HASH ->
  341. EXT_OR_CONN_STATE_OPEN
  342. During EXT_OR_CONN_STATE_OPEN, data is handled by
  343. connection_ext_or_process_inbuf().
  344. */
  345. switch (conn->state) { /* Functionify */
  346. case EXT_OR_CONN_STATE_AUTH_WAIT_AUTH_TYPE:
  347. return connection_ext_or_auth_neg_auth_type(conn);
  348. case EXT_OR_CONN_STATE_AUTH_WAIT_CLIENT_NONCE:
  349. return connection_ext_or_auth_handle_client_nonce(conn);
  350. case EXT_OR_CONN_STATE_AUTH_WAIT_CLIENT_HASH:
  351. return connection_ext_or_auth_handle_client_hash(conn);
  352. default:
  353. log_warn(LD_BUG, "Encountered unexpected connection state %d while trying "
  354. "to process Extended ORPort authentication data.", conn->state);
  355. return -1;
  356. }
  357. }
  358. /** Extended ORPort commands (Transport-to-Bridge) */
  359. #define EXT_OR_CMD_TB_DONE 0x0000
  360. #define EXT_OR_CMD_TB_USERADDR 0x0001
  361. #define EXT_OR_CMD_TB_TRANSPORT 0x0002
  362. /** Extended ORPort commands (Bridge-to-Transport) */
  363. #define EXT_OR_CMD_BT_OKAY 0x1000
  364. #define EXT_OR_CMD_BT_DENY 0x1001
  365. #define EXT_OR_CMD_BT_CONTROL 0x1002
  366. /** Process a USERADDR command from the Extended
  367. * ORPort. <b>payload</b> is a payload of size <b>len</b>.
  368. *
  369. * If the USERADDR command was well formed, change the address of
  370. * <b>conn</b> to the address on the USERADDR command.
  371. *
  372. * Return 0 on success and -1 on error. */
  373. static int
  374. connection_ext_or_handle_cmd_useraddr(connection_t *conn,
  375. const char *payload, uint16_t len)
  376. {
  377. /* Copy address string. */
  378. tor_addr_t addr;
  379. uint16_t port;
  380. char *addr_str;
  381. char *address_part=NULL;
  382. int res;
  383. if (memchr(payload, '\0', len)) {
  384. log_fn(LOG_PROTOCOL_WARN, LD_NET, "Unexpected NUL in ExtORPort UserAddr");
  385. return -1;
  386. }
  387. addr_str = tor_memdup_nulterm(payload, len);
  388. res = tor_addr_port_split(LOG_INFO, addr_str, &address_part, &port);
  389. tor_free(addr_str);
  390. if (res<0)
  391. return -1;
  392. if (port == 0) {
  393. log_warn(LD_GENERAL, "Server transport proxy gave us an empty port "
  394. "in ExtORPort UserAddr command.");
  395. // return -1; // enable this if nothing breaks after a while.
  396. }
  397. res = tor_addr_parse(&addr, address_part);
  398. tor_free(address_part);
  399. if (res<0)
  400. return -1;
  401. { /* do some logging */
  402. char *old_address = tor_addr_to_str_dup(&conn->addr);
  403. char *new_address = tor_addr_to_str_dup(&addr);
  404. log_debug(LD_NET, "Received USERADDR."
  405. "We rewrite our address from '%s:%u' to '%s:%u'.",
  406. safe_str(old_address), conn->port, safe_str(new_address), port);
  407. tor_free(old_address);
  408. tor_free(new_address);
  409. }
  410. /* record the address */
  411. tor_addr_copy(&conn->addr, &addr);
  412. conn->port = port;
  413. if (conn->address) {
  414. tor_free(conn->address);
  415. }
  416. conn->address = tor_addr_to_str_dup(&addr);
  417. return 0;
  418. }
  419. /** Process a TRANSPORT command from the Extended
  420. * ORPort. <b>payload</b> is a payload of size <b>len</b>.
  421. *
  422. * If the TRANSPORT command was well formed, register the name of the
  423. * transport on <b>conn</b>.
  424. *
  425. * Return 0 on success and -1 on error. */
  426. static int
  427. connection_ext_or_handle_cmd_transport(or_connection_t *conn,
  428. const char *payload, uint16_t len)
  429. {
  430. char *transport_str;
  431. if (memchr(payload, '\0', len)) {
  432. log_fn(LOG_PROTOCOL_WARN, LD_NET, "Unexpected NUL in ExtORPort Transport");
  433. return -1;
  434. }
  435. transport_str = tor_memdup_nulterm(payload, len);
  436. /* Transport names MUST be C-identifiers. */
  437. if (!string_is_C_identifier(transport_str)) {
  438. tor_free(transport_str);
  439. return -1;
  440. }
  441. /* If ext_or_transport is already occupied (because the PT sent two
  442. * TRANSPORT commands), deallocate the old name and keep the new
  443. * one */
  444. if (conn->ext_or_transport)
  445. tor_free(conn->ext_or_transport);
  446. conn->ext_or_transport = transport_str;
  447. return 0;
  448. }
  449. #define EXT_OR_CONN_STATE_IS_AUTHENTICATING(st) \
  450. ((st) <= EXT_OR_CONN_STATE_AUTH_MAX)
  451. /** Process Extended ORPort messages from <b>or_conn</b>. */
  452. int
  453. connection_ext_or_process_inbuf(or_connection_t *or_conn)
  454. {
  455. connection_t *conn = TO_CONN(or_conn);
  456. ext_or_cmd_t *command;
  457. int r;
  458. /* DOCDOC Document the state machine and transitions in this function */
  459. /* If we are still in the authentication stage, process traffic as
  460. authentication data: */
  461. while (EXT_OR_CONN_STATE_IS_AUTHENTICATING(conn->state)) {
  462. log_debug(LD_GENERAL, "Got Extended ORPort authentication data (%u).",
  463. (unsigned int) connection_get_inbuf_len(conn));
  464. r = connection_ext_or_auth_process_inbuf(or_conn);
  465. if (r < 0) {
  466. connection_mark_for_close(conn);
  467. return -1;
  468. } else if (r == 0) {
  469. return 0;
  470. }
  471. /* if r > 0, loop and process more data (if any). */
  472. }
  473. while (1) {
  474. log_debug(LD_GENERAL, "Got Extended ORPort data.");
  475. command = NULL;
  476. r = connection_fetch_ext_or_cmd_from_buf(conn, &command);
  477. if (r < 0)
  478. goto err;
  479. else if (r == 0)
  480. return 0; /* need to wait for more data */
  481. /* Got a command! */
  482. tor_assert(command);
  483. if (command->cmd == EXT_OR_CMD_TB_DONE) {
  484. if (connection_get_inbuf_len(conn)) {
  485. /* The inbuf isn't empty; the client is misbehaving. */
  486. goto err;
  487. }
  488. log_debug(LD_NET, "Received DONE.");
  489. /* If the transport proxy did not use the TRANSPORT command to
  490. * specify the transport name, mark this as unknown transport. */
  491. if (!or_conn->ext_or_transport) {
  492. /* We write this string this way to avoid ??>, which is a C
  493. * trigraph. */
  494. or_conn->ext_or_transport = tor_strdup("<?" "?>");
  495. }
  496. connection_write_ext_or_command(conn, EXT_OR_CMD_BT_OKAY, NULL, 0);
  497. /* can't transition immediately; need to flush first. */
  498. conn->state = EXT_OR_CONN_STATE_FLUSHING;
  499. connection_stop_reading(conn);
  500. } else if (command->cmd == EXT_OR_CMD_TB_USERADDR) {
  501. if (connection_ext_or_handle_cmd_useraddr(conn,
  502. command->body, command->len) < 0)
  503. goto err;
  504. } else if (command->cmd == EXT_OR_CMD_TB_TRANSPORT) {
  505. if (connection_ext_or_handle_cmd_transport(or_conn,
  506. command->body, command->len) < 0)
  507. goto err;
  508. } else {
  509. log_notice(LD_NET,"Got Extended ORPort command we don't regognize (%u).",
  510. command->cmd);
  511. }
  512. ext_or_cmd_free(command);
  513. }
  514. return 0;
  515. err:
  516. ext_or_cmd_free(command);
  517. connection_mark_for_close(conn);
  518. return -1;
  519. }
  520. /** <b>conn</b> finished flushing Extended ORPort messages to the
  521. * network, and is now ready to accept OR traffic. This function
  522. * does the transition. */
  523. int
  524. connection_ext_or_finished_flushing(or_connection_t *conn)
  525. {
  526. if (conn->base_.state == EXT_OR_CONN_STATE_FLUSHING) {
  527. connection_start_reading(TO_CONN(conn));
  528. connection_ext_or_transition(conn);
  529. }
  530. return 0;
  531. }
  532. /** Initiate Extended ORPort authentication, by sending the list of
  533. * supported authentication types to the client. */
  534. int
  535. connection_ext_or_start_auth(or_connection_t *or_conn)
  536. {
  537. connection_t *conn = TO_CONN(or_conn);
  538. const uint8_t authtypes[] = {
  539. /* We only support authtype '1' for now. */
  540. EXT_OR_AUTHTYPE_SAFECOOKIE,
  541. /* Marks the end of the list. */
  542. 0
  543. };
  544. log_debug(LD_GENERAL,
  545. "ExtORPort authentication: Sending supported authentication types");
  546. connection_buf_add((const char *)authtypes, sizeof(authtypes), conn);
  547. conn->state = EXT_OR_CONN_STATE_AUTH_WAIT_AUTH_TYPE;
  548. return 0;
  549. }
  550. /** Free any leftover allocated memory of the ext_orport.c subsystem. */
  551. void
  552. ext_orport_free_all(void)
  553. {
  554. if (ext_or_auth_cookie) /* Free the auth cookie */
  555. tor_free(ext_or_auth_cookie);
  556. }