Modularize the server a bit more and update any remaining terminology from older versions of the paper.

Right now, the test client uses a single client instance which performs a given operation (e.g. registration) for x users and x keys, and no real mapping of usernames to keys is recorded client-side. The more realistic model is to have one client instance per user-key mapping.

Make sure the tree roots and STRs follow the structure specified in the paper.

Section 4.3.1 of the CONIKS paper and section 5 of the CONIKS 2.0 report describes a mechanism for making name-to-key mappings in the server private. This is mostly to protect the visibility of public keys via encryption, but could potentially be extended to hiding usernames as well. Only a whitelisted group of users could then access the private mappings. Implementing this requires a whitelisting protocol as well as a corresponding verification protocol.

Maintaining the protobufs in a separate repo would make it easier to ensure that both CONIKS implementations use compatible protobuf messages. Any changes to the protobufs could then be easily propagated to both implementations. This repo would contain the compiled protobufs for each supported language, which can then be imported by each implementation.

Refactor all functions in ServerUtils.java that convert tree nodes ans STRs into byte arrays and make them instance methods for each type.

Update any remaining terminology from older versions of the paper in the server and client. Also make sure messaging functions denote data format (e.g. Proto), and abstract away any data structure-specific terms in public API as much as possible (specifically, rename functions that say ULN change).

Create a function to represent the entire Merkle tree structure as a string.

For simplicity, we were using Strings as the keys, but we should be allowing any key type. This issue should be solved when #2 is done.

Add code used to produce experimental results for client and server overheads in the CONIKS paper, Section 5.3. Also add code for benchmarks requested in coniks-sys/coniks-go/issues/162.

This requires merging @marisbest2's code in the internal CONIKS repo to this repo.

The existing code base should be reorganized into the following packages:

• crypto
• client
• merkletree
• keyserver
• protocol
• utils

These packages should be considered for the future:

• bots for third-party account verification
• storage for persistent storage backend hooks

Change how logging works:

• Have a single logger class
• Use the following logging convention: "[class] error/exception message"

coniks_server.sh checks to see if an instance of the server is already running using grep. Because it searches for SERVER_BIN, which contains ".", the open java file fits that same regex pattern.

Tests show that inserting 10, 100 and 1000 new users into the tree causes extendTree() to hang at the computeHashes() call.

Streamline testing, make it simpler for users to get server+client references running:

• Replace in-class variables with env vars
• Add no-ssl run option for testing

The past release removed a lot of functionality that made automated testing easier. The only way to test the system is by running the server and client directly since they can only communicate over the network.
#16 made interactive testing easy, but removed the ability to test the client automatically.

Currently a single hash function is defined in ServerUtils.java. Since the data to be hashed depends on the tree node, add a hash instance method to each type instead.

Hello,

When I run the command “mvn install” in path “coniks-java/coniks_server” it throws such error.

The same error will throw if I try to build a .jar by running “mvn package”. Therefore, I guess it may be because the target jar files are not in https://repo.maven.apache.org/maven2. May I know if there is any way that I can fix it, please?

Make sure the protos follow the same structure as their Java object counterparts. This will also require changing the server messaging module.

Repeated ints in protos are compiled into ArrayLists of ints, so the current server and client demo implementations have utility functions to convert between byte[] and these ArrayLists. Instead ByteStrings should be used where the protos are used in the server and client.

Same as: coniks-sys/coniks-go#190

From #8: something is wrong with the mixture of proto files, generated Java code, and the provided classes, for instance the field unknownFields in Hash isn't defined anywhere (not in the generated class nor in the underlying com.google.protobuf classes).

The server should generate a temporary binding (per the paper) whenever a client registers a key and return this TB to the client. For now, allow only one TB per epoch.

This includes code in both utils classes, possibly some key and signature ops.

These are needed to keep the username and key data private from other CONIKS clients, and will be integrated into the upcoming Merkle tree library.

We should replace building with make to building with Maven. This should facilitate automated testing and building with new features.

:)

Since the CONIKS auditor will be a separate software package, the CONIKS key server doesn't need to contain any functionality that also makes it an auditor (e.g. reply to observed STR requests). However, once auditors are implemented, the server may end up needing a mechanism for distributing its signed tree roots to auditors.

This also includes editing the protobufs.

The server should generate a cryptographic commitment of the user's name and key data (per the paper) and provide the opening to the client to verify during lookups.

Currently the server only hashes the username string. Need to implement the VUF (per the paper) and have the client verify it during lookups.

The client currently only requests the authentication path upon a lookup, it doesn't also verify it against the epoch's STR.

The project currently doesn't compile as it is:

• syntax error in: https://github.com/citp/coniks-ref-implementation/blob/master/coniks_server/src/org/coniks/coniks_server/UserInfoChanges.java#L62 (can send you a PR for that)
• something is wrong with the mixture of proto files, generated Java code, and the provided classes, for instance the field unknownFields in Hash isn't defined anywhere (not in the generated class nor in the underlying com.google.protobuf classes). Can you compile it locally?