Tor and (SSL) response

Question

I have two questions regarding Tor (onion routing).

How do I receive responds from a server when I use onion routing, I've read that, the last node(exit node) will use the same path I used but in the reverse order, but that means that the last node will know who I am. It was never clear anywhere but I guess that the exit node(node 100) has saved only the node before it , only knows node99 , and node99 knows only node98 etc, but that still doesn't make any sense since if the exit node , knows only the node before it, it will encrypt only with the public key of the node before it, etc.. . So the communication is still not safe.

Also question2

If I the website use SSL how will the onion routing work? If its like this me->encryption node1->encryption node2->...->encryption node100->website running SSL. Will I be the one to encrypt the connection from node100 to the website running SSL, or will node100 do that work? Meaning can node100 view the message I want to send the the website running the SSL and then encrypt the message with the public key of the website, or do I encrypt it the first place making impossible for node100 to view the message. And when the website responds , it will respond encrypting the message with the public key of node 100, right?

Edit to reply to @Phillip

[Me]=>Node[1]=>Node[2]...=Node[Exit]=>SSL-Site , exit node doesn't know the clear text cause I encrypted with the site's public key(SSL).

SSL-Site=>(SSL encrypted with my public key)Node[Exit]=> Node[Exit-1]=>...=>[Me]

How does the site know that the message should be encrypted with my public key, and If it does isnt it easy for an attacker to find out who am I(if he controls that SSL site), also how does Node[Exit] know how to send the response back to me? Is Node[Exit] a trusted node that can betray me or keep me anonymous, meaning all my anonymity depends on how trusted that node is?

Answer 1

The reason onion-routing is called onion-routing is because the encryption has many layers around each other, just like the many layers of skin of an onion.

_{Image Source: Wikipedia}

Every node adds an additional layer of encryption. When you send a message (let's assume non-https for now) via the routers 1, 2 and 3, you encrypt it with the pubkey of router 3, then you take the encrypted message and encrypt it with the key of router 2 and then you take that and encrypt it with the key of router 1. Each router can then "peel off" its layer of encryption, finds another encrypted message and the address of the next router. It then forwards the message to that router. The final router sends the clear-text message to the final recipient. The final router must know the clear-text, because the recipient doesn't expect encrypted communication.

When you additionally use HTTPS, the message itself will also have an additional layer of encryption between you and the recipient. In that case the final router does not learn the true content of the message.

But how do the routers know how to sent the message back? This is only possible when the exit-node also knows the public keys and addresses of all the nodes of the circuit. But in order to encrypt the response, it doesn't need to know the identity of the source. Only the entry-node needs to know this.