RISHABH CHAUHAN | WebAuthn Based Ockam Vault In TypeScript

[rishabh99-rc]

Hii, I am Rishabh Chauhan, a pre-final year computer science undergrad student from Sikkim Manipal Institute of Technology. I have been working on Web Authentication for the past couple of months (using the API & also using Firebase). I also have experience in Typescript, Javascript, MongoDB, React, Nodejs, C++ and have built projects related to the same.

I want to learn more about Public Key Cryptography and Web Authentication (WebAuthn). WebAuthn allows servers to integrate with the strong authenticators now built into devices, like Windows Hello or Apple’s Touch ID. Instead of a password, a private-public keypair (known as a credential) is created for a website. The private key is stored securely on the user’s device; a public key and randomly generated credential ID are sent to the server for storage. The server can then use that public key to prove the user’s identity.

Looking forward to having a discussion and working under the Externship for Ockam.
Thanks!

[rishabh99-rc]

About me

Github | LinkedIn | Twitter

---

I’m a pre-final year computer science undergrad from Sikkim Manipal Insitute of Technology, Sikkim.
My expertise primarily revolves around JavaScript, Typescript, React, MERN, Web Development & Node.js

Being an Army Brat, I have repeatedly been exposed to new cultures and diverse groups of people. This has made me able to quickly adapt to changes and gain a broader perspective in life. I am always curious about things and enjoy learning. Being a detail-oriented person, I like to keep my goals and tasks organized to maintain productivity.

Technologies which I currently work on are -

Typescript/Javascript
C/C++
ReactJS
NodeJS/ExpressJS
NextJS
MongoDB/MYSQL

---

My Experience

Worked as Full Stack Developer Intern at Conglomerate of Global Innovators using the ReactJS and developed code for production.

• Design and develop a meaningful interface. Worked over Firebase as backend.
• Got exposure to deployment and maintenance of websites on hosted networks and Amazon Cloud platform.

Worked as Web Developer Intern at Sparks Foundation.
• Created and/or developed dynamic websites with various specifications.
• Worked on features such as payment gateway and social media integration.
• Collaborated with team members using version control systems such as Git to organize modifications and assign tasks.

---

My Open Source Contributions :

Contributed to Forum2k, Department of IT, SMIT

Solved issue - #38
Link to PR - #45

Solved issue - #37
Link to PR - #43

---

My Projects:

Covid 19 Tracker (Github Repo | Hosted Link)
Tech Stack: React.js, Material UI, Chart.js

• Made using React, Charts.js, and Material UI to fetch data from an API and display it in a very minimalistic way.
• Displays global data in line chart format along-with, individual country data in a bar chart format.

JavaScript Quiz Game (Github Repo | Hosted Link)
Tech Stack - Html, Css, JS

• This is a JavaScript quiz game presented in a multiple-choice question format. It consists of a landing page that prompts
the user to start the game or view the high scores list.
• When the game begins they must answer all the questions within the time limit, which changes dynamically based
on how many questions are in the set.

Student Feedback Sentiment Analysis - Automated robust feedback analysis system. (Github Repo | Hosted Link)
Tech Stack - NLTK, Html, Css, JS.

• Developed an automated robust feedback analysis system with the help of NLTK.
• Applied sentiment analysis using the Naive Bayes algorithm to extract the opinions and subjectivity from the student
feedback.

Game of Life - An interactive demonstration of John Conway's Game of Life. (Github Repo | Hosted Link)
Tech Stack - TypeScript, ReactJs, Nextjs, TailwindCSS, Immer.

Game of Life is a cellular automaton invented by British mathematician John Horton Conway in 1970. It consists of a 2-dimensional grid of cells, each having an alive or dead (or on or off) state. An initial state of the grid can be selected by assigning a state to each cell. New generations of cells can then be created based on the state of the current cells and their neighboring cells with some dead simple rules.
It is a zero-player game, which means that its evolution is determined by just its initial state, requiring no further input.
This project is an interactive implementation of the Game of Life, that allows you to play with it and explore what makes it so special.

Campus Space System [Ongoing] : {Project Synopsis: }

Campus Space System is the Academic Portal with an aim to provide a holistic solution to all student needs.
A MERN Web App where teachers and students can connect with each other. Teachers can upload notes and announcements and students can check them. 🧑‍💻

[rishabh99-rc]

First of all, thank you @mrinalwadhwa for creating such amazing documentation for Ockam. It really helped me a lot to head-start my understanding for End-to-End Encryption with Rust

To be honest sir, I don't have much exposure to the RUST framework but I am willing to read more about it and check out the docs as I have been doing the same. Can't wait to contribute to this project and would love to be a part of this amazing organization.

---

Timeline

So, this is how I have decided to approach my project & have made a rough timeline related to the same.

Week	Goals	Description
1	Mentor-Mentee Bonding	Interaction with the community
2	Understanding	understanding the codebase
3	Architecture creation	making a rough architecture as to how things would work out for us
4	Coding Rust implementation	understanding & coding the rust implementation for protocols
5	Coding	writing a code in TypeScript from the insights given by the mentors
6	Pipe component	Creating pipe component (unidirectional transport).
7	Channel Component	Creating a channel (bidirectional transport).
8	Stream Component	Creating a stream (transport with persistent storage)
9	Improvisation	improving the core logic by discussing with the mentor
10	Documentation	further improvisation by tweaking the code style, modularity & documentation
12	Testing	code testing so that it's production-ready

Time commitments:

I am currently having my End-Sem exams, which will get over by 7th Jan, after that by 23rd Jan our next session would begin in the offline mode, rest I don't have any other commitments during the externship period. So I would be adequately able to commit to the project.

---

Building an end-to-end encryption channel from scratch

Starting off with I tried out the Alice and Bob example -
So, as per my knowledge, Ockam provides a secure way of communicating on the internet avoiding the unwanted, unsecured pathways through which the request flows on the free internet. So when data or information is being passed(handshake) between 2 machines over the internet the data flows through an unwanted and unsecured pathway to reach the destination machine. This path involves a lot of data centers, message queues, etc.

So Ockam makes the communication very easy by just communicating over an Ockam cloud node through TCP protocols with cryptography for safe and secure authentication of the sending and the reaching machines.

Now when it comes to creating a secure channel we can first create a responder node which will start a TCP listener and an echoer worker in this way.

use hello_ockam::Echoer;
use ockam::{Context, Entity, Result, TcpTransport, TrustEveryonePolicy, Vault};

#[ockam::node]
async fn main(ctx: Context) -> Result<()> {
    ctx.start_worker("echoer", Echoer).await?;

    // Initialize the TCP Transport.
    let tcp = TcpTransport::create(&ctx).await?;

  
    tcp.listen("127.0.0.1:4000").await?;


    let vault = Vault::create(&ctx).await?;


    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("bob_listener", TrustEveryonePolicy)
        .await?;

    // Don't call ctx.stop() here so this node runs forever.
    Ok(())
}

The key components required to build the channel.

• Node - The Ockam node is an execution environment that is asynchronous in nature and is used to concurrently execute the workers created.

• Worker - The workers are stateful actors that run un the Ockham node and can start other workers when needed according to logic and can handle and receive messages from different nodes also.

• Routing - the "echoer" nodes that we can create following the docs can only send and receive messages from the default app worker. The routing would allow us to create hops away from our "app" worker to various other nodes created and not only allow us to create single hops but multiple hops to multiple nodes in the network.

• Transport - The Ockam Transport is an additional plugin to Routing allowing us to move Ockam messages in specific protocols like TCP, UDP, WebSockets, Bluetooth, and such. This is important as we can use different protocols depending on the type of data we send through the network. For example, if we have a messaging service then we use TCP protocol, if we are using streaming and even some more complex team chat service application we can use UDP or Websockets and so on.

[rishabh99-rc]

My Implementation

---

Alice Bob Example helps in creating a secure connection between Alice and bob bypassing the route to Bob as a parameter.

Now Alice can send messages that will get encrypted on Alice's side to a routing message and then again decoded to the original message on Bob's end.

The keys are shared mutually by Alice and Bob and no entity in between transport has access to those keys. The process of creating a secure connection between Alice and bob requires multiple handshakes. The routing message can not be modified by hop workers or workers between Alice and Bob.
In this example, both the entities were on a local network. I would like to explore more on how can we make end-to-end encrypted connections with devices connected to the internet. I think the only modification required for that might be to provide a remote address of a node.

---

My Approach

I have gone through the resource shared on the Externship project page regarding the Web Auth, I am currently studying the FIDO2 Framework, as soon as I am done with the implementation, I'll share the screenshot with you.

So my plan is to use all of the encryption and decryption techniques and use them to encrypt the message from an endpoint A to an endpoint B that is secure and passwordless.

P.S: In documentation file the setup for the latest version of Rust can have a command for the Windows users too, else they might face a couple of issues while setting it up, just like @Anurag5086. Though I didn't face this issue, since I use Mac, but while setting up this thing came to my mind, so thought of sharing it with you.