ahmedh409 / deepfake-detection Goto Github PK

The current blockchain uses a singly-linked list, meaning each node only points to the next. The next natural step from a singly-linked list is a doubly-linked list, which would allow traversal in both directions, but both still bottleneck with a query complexity of O(n).
We should consider new data structures for the blockchain as part of a "hardcore refactoring" for the codebase. I had an idea to implement the chain using skip lists which are commonly used in distributed systems and large-scale structures; these have a query complexity of O(log n) instead of linear since they have double links as well as "skip links" which can skip multiple nodes in order to efficiently traverse a list. Here's a paper to introduce the idea.
Another idea is implementing trees (Red-Black?) which tend to have a logarithmic query time, as well. Each "block" could be replaced by a tree which contains media with similar perceptual hashes; in this case, the user would traverse until a "similar" video is found, then it would run down the tree and find the specific video. This seems a little less elegant than skip lists, but could be really interesting - got the idea from the Linux CFS.

Upgrade from image to video hashing. Find a video hashing algorithm - this will be difficult as video processing is an ongoing research field, so finding an easily-implementable open-source video hashing algorithm will be its own task.

Note that this does not replace image hashing but is in addition to it.

A "companion guide" to understanding digital image processing and image hashing for use in writing decent hashing algorithms in application.

GANs may be able to find a target perceptual hash and create deepfakes which can match the perceptual hash. To get around this, we considered the idea of inputting the perceptual hash into a CRYPTOGRAPHIC hashing algorithm - this cryptographic algorithm would be the only hash seen on the blockchain. Cryptographic algorithms can't be replicated on-purpose, so this would be a (relatively) robust method.

Develop a library called Comm which will handle the details of communication between nodes within the simulation. The simulation will use these library functions to handle uploads and searches of the blockchain.

The bulk of the work for v0.2 is complete, but I won't feel good about finalizing this version until we've dealt with a few final bugs, implemented a few more minor features (mostly for our own convenience), and built out a decent test suite.

I'm listing all the things that we need to get done before closing v0.2 below, and we'll add to this over time until we feel it's good to close.

Comms Testing (Sam)

Node Testing (Ahmed)

System Testing (Ahmed)

Minor Features

• make the Simulator pipes bidirectional to allow nodes to pass output directly to the simulator
• automatically clear leftover data from the last run when starting the system again
• make the test suite easier to run/call

A "companion guide" to understanding digital signatures and the cryptography behind it for use in actually developing digital signatures in application.

We need some way to test the entire network without running nodes on several computers. A local simulation with nodes which communicate using TCP channels should be developed for testing.
We might be able to set up the network so it can be tested across multiple processes.

The system currently only supports text data as a test. At a minimum, we need to be able to upload and hash images and videos.

I will edit this issue with more information and a specific course of action.

A "companion guide" to understanding digital video processing and video hashing for use in writing decent hashing algorithms in application.

Nodes should work seamlessly using the CLI with the video-enabled TestChain. Processes can be interrupted and manipulated, and the simulator can be considered developed to a satisfying degree (weak definition).

Refactor code. Improve output to terminal from main.cpp. Clean up code files for whitespace and unused variables, improve comments.

Have a working interface for v0.1 which allows for image hashing and no implementation bugs. A user should be able to:

• perceptually hash an image at a specified local path
• place the hash onto a new block on the TestChain
• search the TestChain for an image and return whether it was found

Nodes need to be detailed such that a user can create n nodes for the v0.2 simulation and have them communicate their processes.

We need to extend the perceptual image hashing implemented in v0.1.

This second iteration will require a considerable amount of research.

This is a continuation of #2

We will need a digital signature scheme to verify and prove the authenticity of messages, such as those which add data to the blockchain.

I am currently doing some background research on this topic. I will type up some notes on how digital signatures work and how we can use them in our system, and I will upload this into the repo.

After that, we can decide on the best approach and begin implementing. It's more important to have a bad implementation that we can improve on than wait forever to try to make it perfect on the first try.