Animesh Das | WebSocket Based Ockam Transport In TypeScript

[animeshdas2000]

Hey Everyone, I am Animesh Das, a pre-final year Computer Science undergraduate at The NorthCap University, Gurugram. I am a tech enthusiast with a deep interest in Web Development, Network Security, Blockchain, and Distributed Systems.

I have been into web development for the past 3 years but I have only been able to make a few open-source contributions this year itself. As a part of my course curriculum, I have been learning about Web security, Cryptography, and Software Vulnerabilities.
I have been primarily been working on the following tech stack

• HTML5 ,CSS3
• Javascript
• Reactjs
• NodeJs (Used express framework)
• MongoDB
• Firebase
• GatsbyJS
• Typescript

Apart from the above, I have also my hands-on REST APIs,GoLang, MySql, Angular,Docker,WordPress, C++(for problem-solving), Java(for 3bn devices :P).

I am new to Rust and definitely want to learn more looking at the scope of the language in End-to-End encryption and Blockchain (Solana network).

After my brief conversation with @mrinalwadhwa on discord, I'm confident if I'm selected as a Github Extern @ Ockam I would learn a lot in the span of three months.

Past Projects

• Cohesion CTF-ARG Platform
  Working on Documentation
  The project was built using Nodejs, Express, EJS, and Firebase for building an open-source CTF platform. You can read more about
  the project in the README.md

• Vortex - Crypto and Stock market Tracker
  In progress
  It is a market watch webApp. I have used Reactjs, Styled-Components for the initial development. I would be continuing with the same in the future.

Open Source Contribution

• Cohesion CTF-ARG Platform
• [Stock market Simulator] (https://github.com/Shriyansh-J/stock_market_simulator)
  Implemented Authentication while mapping its data to Firebase Realtime Database.

Thank you for reading about me and my projects I will share my learning in the Comments of this discussion tab.
Excited to learn and contribute to Ockam!

[animeshdas2000]

E2E with Rust

As per the documentation, we are trying to create a transport connection between Alice and Bob using Ockam. Ockam is beneficial as it will set up an Ockam hub between the two entities. It follows the CIA triad and protects the messages and information end to end in a secure channel.

Due to the dynamic nature of environments where multiple instances of machines and applications enter and leave the network the trust is low considering the amount of cyber risk we have at hand. A better way of approaching this issue is by authenticating on both ends for the users such that the sent and received data does not tamper during transit.

As the data moves through various types of architecture in various types of applications the services have full control over the CRUD permission of the data in transit. The solution has been defined using the Ockam suite of programming, where it does all the heavy lifting of maintaining the CIA by mutual authenticating on both the end using cryptography.
Again the question arises about the existing secure channels like TLS protocols.

Ockam Components

• Node
  An async execution environment that can run stateful actors is known as Worker(more has been mentioned below. We can use #[ockam::node] attribute to inject the init code.
• Workers
  It runs on the Ockam node, while maintaining an Internal state and can start with new workers. Each worker has its own address which is defined by the application. In our example, we are primarily using the Echoer worker for printing the Address and the message sent.
• Routing
  This helps in routing the message sent across. I referred to this README.md
  to get an understanding of how the messages are routed using Hop worker.
• Transport
  This was an important segment of my learning as it wraps the project that I'm applying for. The example given created two nodes a Responder and an initiator in a TcpTransporter. This acted as a middleware between the nodes to keep the communication intact. We create a main async function and then Initialise the TCP transport along with a vault that can store secret keys for Bob
• Secure Channel
  This is the channel where the encryption happens. All the three nodes: Responder, Middle, and Initiator node. This secure channel is established when a secret key between both entities is shared. The key is based on a cryptography key agreement.

I used the following code snippets from the Documentation

Bob's Client ( example/bob.rs )

use ockam::{Context, Entity, Result, TrustEveryonePolicy, Vault};
use ockam::{RemoteForwarder, Routed, TcpTransport, Worker, TCP};

struct Echoer;

// Define an Echoer worker that prints any message it receives and
// echoes it back on its return route.
#[ockam::worker]
impl Worker for Echoer {
    type Context = Context;
    type Message = String;

    async fn handle_message(&mut self, ctx: &mut Context, msg: Routed<String>) -> Result<()> {
        println!("\n[✓] Address: {}, Received: {}", ctx.address(), msg);

        // Echo the message body back on its return_route.
        ctx.send(msg.return_route(), msg.body()).await
    }
}

#[ockam::node]
async fn main(ctx: Context) -> Result<()> {
    // Initialize the TCP Transport.
    TcpTransport::create(&ctx).await?;

    // Create a Vault to safely store secret keys for Bob.
    let vault = Vault::create(&ctx).await?;

    // Create an Entity to represent Bob.
    let mut bob = Entity::create(&ctx, &vault).await?;

    // Create a secure channel listener for Bob that will wait for requests to
    // initiate an Authenticated Key Exchange.
    bob.create_secure_channel_listener("listener", TrustEveryonePolicy)
        .await?;

    // The computer that is running this program is likely within a private network and
    // not accessible over the internet.
    //
    // To allow Alice and others to initiate an end-to-end secure channel with this program
    // we connect with 1.node.ockam.network:4000 as a TCP client and ask the forwarding
    // service on that node to create a forwarder for us.
    //
    // All messages that arrive at that forwarding address will be sent to this program
    // using the TCP connection we created as a client.
    let node_in_hub = (TCP, "1.node.ockam.network:4000");
    let forwarder = RemoteForwarder::create(&ctx, node_in_hub, "listener").await?;
    println!("\n[✓] RemoteForwarder was created on the node at: 1.node.ockam.network:4000");
    println!("Forwarding address for Bob is:");
    println!("{}", forwarder.remote_address());

    // Start a worker, of type Echoer, at address "echoer".
    // This worker will echo back every message it receives, along its return route.
    ctx.start_worker("echoer", Echoer).await?;

    // We won't call ctx.stop() here, this program will run until you stop it with Ctrl-C
    Ok(())
}

Alice Client (examples/alice.rs)

use ockam::{route, Context, Entity, Result, TrustEveryonePolicy, Vault};
use ockam::{TcpTransport, TCP};
use std::io;

#[ockam::node]
async fn main(mut ctx: Context) -> Result<()> {
    // Initialize the TCP Transport.
    TcpTransport::create(&ctx).await?;

    // Create a Vault to safely store secret keys for Alice.
    let vault = Vault::create(&ctx).await?;

    // Create an Entity to represent Alice.
    let mut alice = Entity::create(&ctx, &vault).await?;

    // This program expects that Bob has setup a forwarding address,
    // for his secure channel listener, on the Ockam node at 1.node.ockam.network:4000.
    //
    // From standard input, read this forwarding address for Bob's secure channel listener.
    println!("\nEnter the forwarding address for Bob: ");
    let mut address = String::new();
    io::stdin().read_line(&mut address).expect("Error reading from stdin.");
    let forwarding_address = address.trim();

    // Combine the tcp address of the node and the forwarding_address to get a route
    // to Bob's secure channel listener.
    let route_to_bob_listener = route![(TCP, "1.node.ockam.network:4000"), forwarding_address];

    // As Alice, connect to Bob's secure channel listener, and perform an
    // Authenticated Key Exchange to establish an encrypted secure channel with Bob.
    let channel = alice
        .create_secure_channel(route_to_bob_listener, TrustEveryonePolicy)
        .await?;

    println!("\n[✓] End-to-end encrypted secure channel was established.\n");

    loop {
        // Read a message from standard input.
        println!("Type a message for Bob's echoer:");
        let mut message = String::new();
        io::stdin().read_line(&mut message).expect("Error reading from stdin.");
        let message = message.trim();

        // Send the provided message, through the channel, to Bob's echoer.
        ctx.send(route![channel.clone(), "echoer"], message.to_string()).await?;

        // Wait to receive an echo and print it.
        let reply = ctx.receive::<String>().await?;
        println!("Alice received an echo: {}\n", reply); // should print "Hello Ockam!"
    }

    // This program will keep running until you stop it with Ctrl-C
}

Issues I faced while going through the documentation

• cargo build failing
  • ISSUE: rust default windows architecture issue
  • Resolved by using rustup default stable-x86_64-pc-windows-gnu (stackoverflow)