The browser edition of ndn-js was developed in 2013. Since then, the JavaScript ecosystem has evolved greatly, but ndn-js has not been able to keep up.This causes several difficulties when integrating ndn-js in a modern JavaScript project.
This project is to modernize several aspects of ndn-js, so that it can work well in today’s JavaScript ecosystem.

Briefly describe the tasks

Replace Waf build process with a modern bundler such as Brunch or Webpack.
The goal is to allow a web application to require("ndn-js") and have the bundler do the rest.
The ability of building a self-contained ndn.js must be preserved.
If feasible, remove the copied dependencies in contrib/, and import them from NPM.

Provide TypeScript declaration file to enable type checking of ndn-js APIs in a TypeScript project.
These commonly used classes should be given priority: Name Name.Component Interest Data NetworkNack Blob Face.
Others may be declared as any type.

Add Promise-based APIs as an alternate to callback-based APIs.
These functions need an alternate that returns a Promise: Face.expressInterest Face.registerPrefix KeyChain.createIdentityV2.
These functions need an alternate that takes a callback whose return value is a Promise: Face.setInterestFilter Face.registerPrefix.

The understanding of traffic flow is important in development of resilient network tools. 3D NDN Visualization could aid in providing a more efficient method of analyzing and interpreting traffic data.

Briefly describe the tasks

Investigate existing tools for identifying and analyzing network traffic, use available network data to evaluate promising tools, and attempt to create a visualization using the output of these tools.

Any specific tools or language

Since the visualization will be developed using the Unity engine, the main language that will be used will be C#

Expected outcomes

A simple visualization that can be further developed into a working 3D visualization prototype.

7. Refactor encoding and decoding in NDN-RIOT and make it more usable to developers

Certificate Support in esp8266ndn Library

esp8266ndn https://github.com/yoursunny/esp8266ndn is an Arduino library that supports NDN application development on ESP8266 and ESP32 microcontrollers.
University of Memphis and NIST each has a building sensing deployment utilizing this library.

So far esp8266ndn supports HMAC and EC signing and verification, but the application must provide uncompressed key bits.
This project adds a NDN Certificate v2 https://named-data.net/doc/ndn-cxx/current/specs/certificate-format.html decoder and encoder to the esp8266ndn library, paving the way of implementing trust schema, ndncert-client, and secure device onboarding in the future.

Briefly describe the tasks

Study the encoding format (including common variations if any) of X509PublicKeyContent used in NDN Certificate.

Implement or adapt an ASN.1 encoder and decoder for ESP8266/ESP32 Arduino.

Implement a NDN Certificate decoder to extract public key and validity period from a DataLite instance.

Implement a NDN Certificate encoder to create a DataLite from name, public key, and validity period, and then sign it with an existing EcPrivateKey.

Any specific tools or language

Participant must have access to one ESP8266 or ESP32 microcontroller.

Participant must have access to a 2.4GHz WiFi network and an NFD node on this network.

Participant should be able to read ndn-cxx code related to certificates.

Expected outcomes

Certificate decoder demo:

Operator enters a Data name through serial console.

Microcontroller retrieves the Data packet.

Microcontroller follows KeyLocator to retrieve the certificate.

Microcontroller decodes the certificate and verifies the Data packet against the public key embedded in the certificate, and then prints verification result on the serial console.

Certificate encoder demo:

Upon startup, microcontroller generates an EC key pair and a self-signed certificate.

Operator executes a consumer program on the computer (written in ndn-cxx or PyNDN or similar) to retrieve microcontroller’s certificate and a Data packet signed by its private key.

The consumer program decodes the certificate and verifies the Data packet against the public key embedded in the certificate, and then prints verification result on standard output.

Tiny Forwarder with esp8266ndn Library

esp8266ndn https://github.com/yoursunny/esp8266ndn is an Arduino library that supports NDN application development on ESP8266 and ESP32 microcontrollers. University of Memphis and NIST each has a building sensing deployment utilizing this library. In both systems, the sensor nodes is one hop away from an NFD node.

This project explores a specific design of a tiny forwarder on the ESP8266/ESP32 microcontrollers.
Given the memory constraint, this tiny forwarder uses per-face Bloom filters as the Pending Interest Table (PIT), instead of a regular name-based PIT. It sacrifices preciseness of PIT name matching and InterestLifetime, in exchange for lower memory requirement.

If this design is proven to be successful, building sensing deployments can reduce dependency on the infrastructure network.
In the future, it’s also possible to port the same design to NDN-RIOT.

HMAC and Merkle-Hash-Tree Signatures in ndn-cxx

SignatureHmacWithSha256 is one of the signature types defined in NDN Packet Format. It ensures provenance that the Data packet was signed by one of the parties who holds the shared key. Common Client Libraries (CCL) support this signature type, but ndn-cxx does not.

The NDNFS daemon creates a FUSE mountpoint. When a file is added under this FUSE mountpoint, it internally segments the file into Data packets and generates signatures. These Data packets can then be served over the network. This method causes difficulty in serving large number of existing files because they must be copied into FUSE, and has several bugs when files are added via SFTP.

This project explores a different kind of NDN File System. Instead of using FUSE, the program works with an existing folder on the filesystem. When an Interest arrives, it segments and signs the Data on the fly, and caches the signature. The user experience is similar to python3 -m http.server

Briefly describe the tasks

Develop a daemon program that serves files in the current working directory.
Assuming the files do not change, the Data packets can used a fixed version number.
Files should be retrievable with ndncatchunks using fixed version discovery.

Add signature caching to reduce signing overhead.

Add directory listing feature using a simple protocol, and develop a client program to retrieve directory listing.

Add Realtime Data Retrieval protocol support to accomodate file updates.
Files should be retrievable with ndncatchunks using RDR version discovery method; in case this discovery method isn’t available at time of project, the participant would have to develop a ndn-tools patch for this.

Develop systemd service file for the daemon.

Any specific tools or language

Participant must be familiar with either ndn-cxx or Common Client Libraries

Expected outcomes

Show the result of listed tasks in simple console applications.

Packet03, Data Synchronization, and More in repo-sql

repo-sql https://github.com/3rd-ndn-hackathon/repo-sql is an alternate NDN repository implementation backed by a SQL database. It was developed in 3rd NDN Hackathon, and is still being maintained. Two years later, it is in need of a refresh.

This project switches repo-sql to use NDN Packet Format 0.3 (packet03), which greatly simplifies the QueryProcessor. Also, repo-sql can have Data synchronization using the C++ PSync library.

Develop a data synchronization mechanism.
The primary repo-sql instance has all the Data, and applications should only write to the primary instance.
Secondary repo-sql instances mirrors a subset of stored Data under one or more specified name prefixes using PSync.
This is a one-way mirroring at this stage: the secondary instances do not allow direct insertion.