[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[tor-commits] [obfsproxy/master] Dump the silly get_other_conn() hack; use configurable circuits.



commit 3d85a235c6a6729eeac92413c2fcb982d4578a57
Author: George Kadianakis <desnacked@xxxxxxxxx>
Date:   Sat Aug 20 16:28:13 2011 +0200

    Dump the silly get_other_conn() hack; use configurable circuits.
    
    * Introduce (*circuit_create) and (*circuit_free) which allow the module
      writer to configure his circuits.
    * Put the obfs2 state in a circuit instead of a connection.
---
 src/network.c             |   13 ++++++++--
 src/protocol.c            |   24 +++++++++++++++++++++
 src/protocol.h            |   12 ++++++++++
 src/protocols/dummy.c     |   19 ++++++++++++++++
 src/protocols/dummy.h     |    4 +++
 src/protocols/obfs2.c     |   51 +++++++++++++++++++++++++++-----------------
 src/protocols/obfs2.h     |    6 ++++-
 src/test/unittest_obfs2.c |   51 ++++++++++++++++++++++++++++++++++----------
 8 files changed, 144 insertions(+), 36 deletions(-)

diff --git a/src/network.c b/src/network.c
index 0fd5e4d..91b1237 100644
--- a/src/network.c
+++ b/src/network.c
@@ -378,7 +378,9 @@ circuit_create(conn_t *up, conn_t *down)
   if (!up || !down)
     return -1;
 
-  circuit_t *r = xzalloc(sizeof(circuit_t));
+  obfs_assert(up->cfg == down->cfg);
+
+  circuit_t *r = proto_circuit_create(up->cfg);
   r->upstream = up;
   r->downstream = down;
   up->circuit = r;
@@ -391,7 +393,7 @@ circuit_create_socks(conn_t *up)
 {
   obfs_assert(up);
 
-  circuit_t *r = xzalloc(sizeof(circuit_t));
+  circuit_t *r = proto_circuit_create(up->cfg);
   r->upstream = up;
   r->socks_state = socks_state_new();
   up->circuit = r;
@@ -410,6 +412,10 @@ circuit_add_down(circuit_t *circuit, conn_t *down)
 static void
 circuit_free(circuit_t *circuit)
 {
+  /* keep the cfg so that we can use its vtable for proto_circuit_free() */
+  config_t *cfg = circuit->upstream->cfg;
+  obfs_assert(cfg);
+
   /* break the circular references before deallocating each side */
   circuit->upstream->circuit = NULL;
   conn_free(circuit->upstream);
@@ -419,7 +425,8 @@ circuit_free(circuit_t *circuit)
   }
   if (circuit->socks_state)
     socks_state_free(circuit->socks_state);
-  free(circuit);
+
+  proto_circuit_free(circuit, cfg);
 }
 
 /**
diff --git a/src/protocol.c b/src/protocol.c
index 14437e6..81fd454 100644
--- a/src/protocol.c
+++ b/src/protocol.c
@@ -165,3 +165,27 @@ proto_conn_free(conn_t *conn) {
   obfs_assert(conn->cfg->vtable->conn_free);
   conn->cfg->vtable->conn_free(conn);
 }
+
+/**
+   This protocol is called everytime a circuit has to be created.
+   Return a circuit_t on success or a NULL on fail.
+*/
+circuit_t *
+proto_circuit_create(config_t *cfg)
+{
+  obfs_assert(cfg);
+  obfs_assert(cfg->vtable);
+  obfs_assert(cfg->vtable->circuit_create);
+  return cfg->vtable->circuit_create(cfg);
+}
+
+/**
+   This function destroys 'circuit', using the vtable off 'cfg'.
+*/
+void
+proto_circuit_free(circuit_t *circuit, config_t *cfg) {
+  obfs_assert(cfg);
+  obfs_assert(cfg->vtable);
+  obfs_assert(cfg->vtable->circuit_free);
+  cfg->vtable->circuit_free(circuit);
+}
diff --git a/src/protocol.h b/src/protocol.h
index ede91f1..d360594 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -62,6 +62,12 @@ struct protocol_vtable
   /** Destroy per-connection, protocol-specific state.  */
   void (*conn_free)(conn_t *state);
 
+  /** A 'circuit_t' needs to be created. */
+  circuit_t *(*circuit_create)(config_t *cfg);
+
+  /** Destroy a 'circuit_t'.  */
+  void (*circuit_free)(circuit_t *circuit);
+
   /** Perform a connection handshake. Not all protocols have a handshake. */
   int (*handshake)(conn_t *state, struct evbuffer *buf);
 
@@ -92,6 +98,8 @@ struct protocol_vtable
     name##_config_get_target_addr,              \
     name##_conn_create,                         \
     name##_conn_free,                           \
+    name##_circuit_create,                      \
+    name##_circuit_free,                        \
     name##_handshake, name##_send, name##_recv  \
   }
 
@@ -107,6 +115,10 @@ struct evutil_addrinfo *config_get_target_addr(config_t *cfg);
 conn_t *proto_conn_create(config_t *cfg);
 void proto_conn_free(conn_t *conn);
 
+circuit_t *proto_circuit_create(config_t *cfg);
+void proto_circuit_free(circuit_t *conn, config_t *cfg);
+
+
 int proto_handshake(conn_t *conn, void *buf);
 int proto_send(conn_t *conn, void *source, void *dest);
 enum recv_ret proto_recv(conn_t *conn, void *source, void *dest);
diff --git a/src/protocols/dummy.c b/src/protocols/dummy.c
index 27e6340..21fd3ca 100644
--- a/src/protocols/dummy.c
+++ b/src/protocols/dummy.c
@@ -22,6 +22,12 @@ downcast_conn(conn_t *p)
   return DOWNCAST(dummy_conn_t, super, p);
 }
 
+static inline dummy_circuit_t *
+downcast_circuit(circuit_t *p)
+{
+  return DOWNCAST(dummy_circuit_t, super, p);
+}
+
 /**
    Helper: Parses 'options' and fills 'cfg'.
 */
@@ -174,6 +180,19 @@ dummy_conn_free(conn_t *proto)
   free(downcast_conn(proto));
 }
 
+static circuit_t *
+dummy_circuit_create(config_t *cfg)
+{
+  dummy_circuit_t *circuit = xzalloc(sizeof(dummy_circuit_t));
+  return &circuit->super;
+}
+
+static void
+dummy_circuit_free(circuit_t *circ)
+{
+  free(downcast_circuit(circ));
+}
+
 /** Dummy has no handshake */
 static int
 dummy_handshake(conn_t *proto, struct evbuffer *buf)
diff --git a/src/protocols/dummy.h b/src/protocols/dummy.h
index d243f06..3dc1995 100644
--- a/src/protocols/dummy.h
+++ b/src/protocols/dummy.h
@@ -33,6 +33,10 @@ typedef struct dummy_conn_t {
   conn_t super;
 } dummy_conn_t;
 
+typedef struct dummy_circuit_t {
+  circuit_t super;
+} dummy_circuit_t;
+
 #endif
 
 #endif
diff --git a/src/protocols/obfs2.c b/src/protocols/obfs2.c
index 42a1c04..6e241c3 100644
--- a/src/protocols/obfs2.c
+++ b/src/protocols/obfs2.c
@@ -22,6 +22,13 @@ downcast_conn(conn_t *p)
   return DOWNCAST(obfs2_conn_t, super, p);
 }
 
+static inline obfs2_circuit_t *
+downcast_circuit(circuit_t *p)
+{
+  return DOWNCAST(obfs2_circuit_t, super, p);
+}
+
+
 static int parse_and_set_options(int n_options,
                                  const char *const *options,
                                  obfs2_config_t *params);
@@ -44,20 +51,10 @@ shared_seed_nonzero(const uchar *seed)
   return memcmp(seed, SHARED_ZERO_SEED, SHARED_SECRET_LENGTH) != 0;
 }
 
-/**
-   Stupid temporary function returning the other conn of a circuit.
-   For example, if 'conn' is the downstream connection on a circuit,
-   this function returns the upstream connection.
-*/
-static inline conn_t *
-get_other_conn(conn_t *conn)
+static inline obfs2_state_t *
+get_state_from_conn(conn_t *conn)
 {
-  if (conn->circuit->upstream == conn) {
-    return conn->circuit->downstream;
-  } else {
-    obfs_assert(conn->circuit->downstream == conn);
-    return conn->circuit->upstream;
-  }
+  return downcast_circuit(conn->circuit)->state;
 }
 
 static void
@@ -246,7 +243,6 @@ obfs2_conn_create(config_t *cfg)
   obfs2_conn_t *conn = xzalloc(sizeof(obfs2_conn_t));
   conn->super.cfg = cfg;
   conn->super.mode = downcast_config(cfg)->mode;
-  conn->state = state_create(cfg);
 
   return &conn->super;
 }
@@ -254,10 +250,25 @@ obfs2_conn_create(config_t *cfg)
 static void
 obfs2_conn_free(conn_t *conn)
 {
-  obfs2_conn_t *obfs2_conn = downcast_conn(conn);
+  free(downcast_conn(conn));
+}
+
+static circuit_t *
+obfs2_circuit_create(config_t *cfg)
+{
+  obfs2_circuit_t *circuit = xzalloc(sizeof(obfs2_circuit_t));
+  circuit->state = state_create(cfg);
+
+  return &circuit->super;
+}
+
+static void
+obfs2_circuit_free(circuit_t *circuit)
+{
+  obfs2_circuit_t *obfs2_circuit = downcast_circuit(circuit);
 
-  obfs2_destroy(obfs2_conn->state);
-  free(obfs2_conn);
+  obfs2_destroy(obfs2_circuit->state);
+  free(obfs2_circuit);
 }
 
 /**
@@ -402,7 +413,7 @@ obfs2_destroy(obfs2_state_t *state)
 static int
 obfs2_handshake(conn_t *s, struct evbuffer *buf)
 {
-  obfs2_state_t *state = downcast_conn(s)->state;
+  obfs2_state_t *state = get_state_from_conn(s);
 
   uint32_t magic = htonl(OBFUSCATE_MAGIC_VALUE), plength, send_plength;
   uchar msg[OBFUSCATE_MAX_PADDING + OBFUSCATE_SEED_LENGTH + 8];
@@ -474,7 +485,7 @@ static int
 obfs2_send(conn_t *s,
            struct evbuffer *source, struct evbuffer *dest)
 {
-  obfs2_state_t *state = downcast_conn(get_other_conn(s))->state;
+  obfs2_state_t *state = get_state_from_conn(s);
 
   if (state->send_crypto) {
     /* First of all, send any data that we've been waiting to send. */
@@ -554,7 +565,7 @@ static enum recv_ret
 obfs2_recv(conn_t *s, struct evbuffer *source,
            struct evbuffer *dest)
 {
-  obfs2_state_t *state = downcast_conn(s)->state;
+  obfs2_state_t *state = get_state_from_conn(s);
 
   if (state->state == ST_WAIT_FOR_KEY) {
     /* We're waiting for the first OBFUSCATE_SEED_LENGTH+8 bytes to show up
diff --git a/src/protocols/obfs2.h b/src/protocols/obfs2.h
index a8fe2cc..fb07407 100644
--- a/src/protocols/obfs2.h
+++ b/src/protocols/obfs2.h
@@ -79,9 +79,13 @@ typedef struct obfs2_config_t {
 
 typedef struct obfs2_conn_t {
   conn_t super;
-  obfs2_state_t *state;
 } obfs2_conn_t;
 
+typedef struct obfs2_circuit_t {
+  circuit_t super;
+  obfs2_state_t *state;
+} obfs2_circuit_t;
+
 #endif
 
 #endif
diff --git a/src/test/unittest_obfs2.c b/src/test/unittest_obfs2.c
index 6e14b1e..7037788 100644
--- a/src/test/unittest_obfs2.c
+++ b/src/test/unittest_obfs2.c
@@ -21,6 +21,18 @@ downcast(conn_t *proto)
   return DOWNCAST(obfs2_conn_t, super, proto);
 }
 
+static inline obfs2_circuit_t *
+downcast_circuit(circuit_t *p)
+{
+  return DOWNCAST(obfs2_circuit_t, super, p);
+}
+
+static inline obfs2_state_t *
+get_state_from_conn(conn_t *conn)
+{
+  return downcast_circuit(conn->circuit)->state;
+}
+
 static void
 test_obfs2_option_parsing(void *unused)
 {
@@ -81,7 +93,9 @@ struct test_obfs2_state
   config_t *cfg_client;
   config_t *cfg_server;
   conn_t *conn_client;
+  conn_t *conn2_client; /* dummy conn to build a circuit */
   conn_t *conn_server;
+  conn_t *conn2_server; /* dummy conn to build a circuit */
   struct evbuffer *output_buffer;
   struct evbuffer *dummy_buffer;
 };
@@ -91,10 +105,17 @@ cleanup_obfs2_state(const struct testcase_t *unused, void *state)
 {
   struct test_obfs2_state *s = (struct test_obfs2_state *)state;
 
+  proto_circuit_free(s->conn_client->circuit, s->cfg_client);
   if (s->conn_client)
     proto_conn_free(s->conn_client);
+  if (s->conn2_client)
+    proto_conn_free(s->conn2_client);
+
+  proto_circuit_free(s->conn_server->circuit, s->cfg_server);
   if (s->conn_server)
     proto_conn_free(s->conn_server);
+  if (s->conn2_server)
+    proto_conn_free(s->conn2_server);
 
   if (s->cfg_client)
     config_free(s->cfg_client);
@@ -136,6 +157,15 @@ setup_obfs2_state(const struct testcase_t *unused)
   s->conn_server = proto_conn_create(s->cfg_server);
   tt_assert(s->conn_server);
 
+  s->conn2_client = proto_conn_create(s->cfg_client);
+  tt_assert(s->conn2_client);
+
+  s->conn2_server = proto_conn_create(s->cfg_server);
+  tt_assert(s->conn2_server);
+
+  tt_assert(!(circuit_create(s->conn_client, s->conn2_client)<0));
+  tt_assert(!(circuit_create(s->conn_server, s->conn2_server)<0));
+
   s->output_buffer = evbuffer_new();
   tt_assert(s->output_buffer);
 
@@ -156,8 +186,8 @@ static void
 test_obfs2_handshake(void *state)
 {
   struct test_obfs2_state *s = (struct test_obfs2_state *)state;
-  obfs2_state_t *client_state = downcast(s->conn_client)->state;
-  obfs2_state_t *server_state = downcast(s->conn_server)->state;
+  obfs2_state_t *client_state = get_state_from_conn(s->conn_client);
+  obfs2_state_t *server_state = get_state_from_conn(s->conn_server);
 
   /* We create a client handshake message and pass it to output_buffer */
   tt_int_op(0, <=, proto_handshake(s->conn_client, s->output_buffer));
@@ -167,6 +197,7 @@ test_obfs2_handshake(void *state)
   tt_assert(RECV_GOOD == proto_recv(s->conn_server, s->output_buffer,
                                     s->dummy_buffer));
 
+
   /* Now, we create the server's handshake and pass it to output_buffer */
   tt_int_op(0, <=, proto_handshake(s->conn_server, s->output_buffer));
 
@@ -193,10 +224,6 @@ test_obfs2_transfer(void *state)
   int n;
   struct evbuffer_iovec v[2];
 
-  /* evil trick to bypass get_other_conn() */
-  circuit_create(s->conn_client, s->conn_client);
-  circuit_create(s->conn_server, s->conn_server);
-
   /* Handshake */
   tt_int_op(0, <=, proto_handshake(s->conn_client, s->output_buffer));
   tt_assert(RECV_GOOD == proto_recv(s->conn_server, s->output_buffer,
@@ -254,8 +281,8 @@ static void
 test_obfs2_split_handshake(void *state)
 {
   struct test_obfs2_state *s = (struct test_obfs2_state *)state;
-  obfs2_state_t *client_state = downcast(s->conn_client)->state;
-  obfs2_state_t *server_state = downcast(s->conn_server)->state;
+  obfs2_state_t *client_state = get_state_from_conn(s->conn_client);
+  obfs2_state_t *server_state = get_state_from_conn(s->conn_server);
 
   uint32_t magic = htonl(OBFUSCATE_MAGIC_VALUE);
   uint32_t plength1, plength1_msg1, plength1_msg2, send_plength1;
@@ -372,8 +399,8 @@ static void
 test_obfs2_wrong_handshake_magic(void *state)
 {
   struct test_obfs2_state *s = (struct test_obfs2_state *)state;
-  obfs2_state_t *client_state = downcast(s->conn_client)->state;
-  obfs2_state_t *server_state = downcast(s->conn_server)->state;
+  obfs2_state_t *client_state = get_state_from_conn(s->conn_client);
+  obfs2_state_t *server_state = get_state_from_conn(s->conn_server);
 
   uint32_t wrong_magic = 0xD15EA5E;
 
@@ -411,8 +438,8 @@ static void
 test_obfs2_wrong_handshake_plength(void *state)
 {
   struct test_obfs2_state *s = (struct test_obfs2_state *)state;
-  obfs2_state_t *client_state = downcast(s->conn_client)->state;
-  obfs2_state_t *server_state = downcast(s->conn_server)->state;
+  obfs2_state_t *client_state = get_state_from_conn(s->conn_client);
+  obfs2_state_t *server_state = get_state_from_conn(s->conn_server);
 
   uchar msg[OBFUSCATE_MAX_PADDING + OBFUSCATE_SEED_LENGTH + 8 + 1];
   uint32_t magic = htonl(OBFUSCATE_MAGIC_VALUE);



_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits