tor

Pros of real-world-onion-sites

• Provides a curated list of legitimate .onion sites, enhancing user discovery
• Regularly updated with new additions and removals
• Includes categorization and brief descriptions of listed sites

Cons of real-world-onion-sites

• Limited in scope compared to the full Tor project
• Does not provide actual anonymity or privacy tools
• Relies on community contributions for updates

Code comparison

tor:

static int
circuit_handle_first_hop(origin_circuit_t *circ)
{
  int ret;
  const node_t *node;
  // ... (additional code)
}

real-world-onion-sites:

## News And Media

### ProPublica
* http://p53lf57qovyuvwsc6xnrppyply3vtqm7l6pcobkmyqsiofyeznfu5uqd.onion/
  * :lock: SSL/TLS available
  * frontend for propublica.org

The tor repository contains the core implementation of the Tor network, focusing on anonymity and privacy. In contrast, real-world-onion-sites is a markdown-based list of legitimate .onion sites, serving as a directory for Tor users. While tor provides the underlying technology, real-world-onion-sites complements it by offering a curated list of destinations within the Tor network.

Pros of OnionShare

• User-friendly GUI for easy file sharing and anonymous hosting
• Supports multiple features like chat rooms and website publishing
• Designed for non-technical users, making Tor technology more accessible

Cons of OnionShare

• Limited to specific use cases (file sharing, chat, website hosting)
• Smaller developer community and less frequent updates
• Depends on Tor for its core functionality

Code Comparison

Tor (C):

int
connection_ap_handshake_process_socks(entry_connection_t *conn)
{
  socks_request_t *socks;
  int sockshere;
  or_options_t *options = get_options();
  // ... (additional code)
}

OnionShare (Python):

def start_onion_service(self):
    self.auth_string = None
    if self.settings.get('auth_type') != 'none':
        self.auth_string = base64.b64encode(os.urandom(33))
    # ... (additional code)

The code snippets highlight the different languages and approaches used in each project. Tor, written in C, focuses on low-level networking and protocol implementation. OnionShare, written in Python, emphasizes higher-level functionality and user interaction.

Pros of mkp224o

• Specialized tool for generating vanity .onion addresses
• Faster and more efficient for its specific purpose
• Lightweight and easy to use for a single task

Cons of mkp224o

• Limited functionality compared to the full Tor implementation
• Not actively maintained or updated as frequently
• Lacks the extensive security auditing of the main Tor project

Code Comparison

mkp224o (main.c):

int main(int argc,char **argv)
{
    parse_cmdline(argc,argv);
    init_globals();
    worker();
    return 0;
}

Tor (main.c):

int main(int argc, char *argv[])
{
  int result = 0;
  tor_init(argc, argv);
  result = do_main_loop();
  tor_cleanup();
  return result;
}

Summary

mkp224o is a specialized tool for generating vanity .onion addresses, offering faster performance for this specific task. However, it lacks the comprehensive features and security measures of the full Tor implementation. The code comparison shows mkp224o's focused approach versus Tor's more complex initialization and main loop structure.

Pros of obfs4

• Specialized in traffic obfuscation, making it harder to detect Tor usage
• Lighter weight and more focused on a single purpose
• Easier to integrate into other projects due to its modular design

Cons of obfs4

• Limited functionality compared to the full Tor implementation
• Requires additional setup and configuration to work with Tor
• Less active development and smaller community support

Code Comparison

tor:

static int
connection_handle_read_impl(connection_t *conn)
{
  int ret = 0;
  ssize_t max_to_read;

  if (conn->marked_for_close)
    return 0;

  conn->timestamp_last_read_allowed = approx_time();

obfs4:

func (t *Transport) ServerHandshake(conn net.Conn) (net.Conn, error) {
	defer func() {
		if err := recover(); err != nil {
			log.Debugf("ServerHandshake failed: %s", err)
		}
	}()

	return t.serverHandshake(conn)
}

The tor project is primarily written in C, focusing on the entire Tor network implementation. obfs4 is written in Go and specializes in obfuscation techniques. While tor handles various aspects of the network, obfs4 concentrates on making traffic appear random to evade detection.