ext_orport.c 21 KB

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