• Stars
    star
    107
  • Rank 323,587 (Top 7 %)
  • Language
    Go
  • License
    GNU General Publi...
  • Created almost 7 years ago
  • Updated over 2 years ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Blockchain based anonymous distributed ID system using RSA Blind Signatures

darkID: A proof of concept of an anonymous decentralized identification system based on blockchain

Blockchain based anonymous decentralized ID system

( Full slides in: https://github.com/arnaucode/darkID/blob/master/darkID-presentation.pdf )

1.- Main concept

The main idea behind darkID is to implement a proof of concept of a decentralized system that allows platforms to identify verified users, but ensuring their anonymity. The main point, is to ensure anonymity, but at the same time, allow users to verify their identity, to ensure that no fake accounts are being used.

2.- How it works

  • Verify the non anonymous ID of an user
    • Based on the: username, email, phone, ID card, etc
  • From a logged and verified user, generate an anonymous darkID (Public Key, and save the Private Key into the storage), and get that darkID signed by an authority (serverIDsigner), with high reputation, and without knowing what is signing, to ensure the anonymity of the user
  • Once the darkID (Public Key) is signed by an authority server, add the darkID to the blockchain (ethereum, or some other)
  • Use the darkID to authenticate in platforms (just need to point the darkID reference in the blockchain), and the platform will send a challenge to the user, to resolve it with the Private Key assigned to the darkID from the darkID desktop app.
type DarkID struct {
	ID             string         `json:"id"`
	PrivK          string         `json:"privK"` //path of the PrivK file
	PubK           string         `json:"pubK"`  //path of the PubK file
	PublicKey      string         `json:"publicKey"`
	Date           time.Time      `json:"date"`
	Hashed         []byte         `json:"hashed"`
	UnblindedSig   []byte         `json:"unblindedsig"`
	Verified       bool           `json:"verified"`
	ServerVerifier *rsa.PublicKey `json:"serververifier"`
	SignerID       string         `json:"signerid"`
	BlockchainRef  string         `json:"blockchainref"`
}

2.1.- Infraestructure

network

2.2.1.- serverIDsigner

  • The server where the user creates a non anonymous account
  • Also is the server that blind signs the anonymous ID of the users
  • This server must be a recognized authority, or based on some reputation system. As only the reliable serverIDsigner will be used by the users to trust their ID validation
  • The serverIDsigner, can be different servers, based on a public reputation, where the users trust the servers that their are using to verify their darkIDs.

2.2.2.- ethereum Smart Contract

Where the darkID is stored. In this case, is a very simple smart contract.

2.2.3.- Desktop app

An electron desktop app implemented in Angularjs and Go lang.

screenshot

screenshot

screenshot

2.2.- Step by step process

  • Once all the nodes of the network are running, a new user can connect to the serverIDsigner.
  • The user registers a non anonymous user (using email, phone, password, etc), and performs the login with that user
  • The user, locally, generates a RSA key pair (private key & public key)
  • The user blinds his Public-Key with the serverIDsigner Public-Key
  • The user's Public-Key blinded, is sent to the serverIDsigner
  • The serverIDsigner Blind Signs the Public-Key blinded from the user, and returns it to the user
  • The user unblinds the Public-Key signed by the serverIDsigner, and now has the Public-Key Blind Signed by the serverIDsigner
  • The user sends the Public-Key blind signed to the p2p network
  • The peers verify that the Public-Key Blind Signed is correctly signed by the serverIDsigner, if it is, they add the Public-Key to the Ethereum Blockchain, inside a new block

creation

  • Then, when the user wants to login into a platform, just needs to put his Public-Key
  • The platform goes to the Ethereum Blockchain, to check if this Public-Key is registered in the blockchain
  • The platform sends a message encrypted with the user Public-Key, and the user returns the message decrypted with the Private-Key, to verify that is the owner of that Public-Key

login

The user Private Keys are stored only in the user local directory 'darkID/keys'.

3.- Cryptography

3.1.- RSA encryption system

https://en.wikipedia.org/wiki/RSA_cryptosystem

  • Public parameters: (e, n)
  • Private parameters: (d, p, q, phi, sigma)
  • Public-Key = (e, n)
  • Private-Key = (d, n)
  • Encryption: rsa
  • Decryption: rsa

3.2.- Blind signature process

https://en.wikipedia.org/wiki/Blind_signature

  • m is the message (in our case, is the Public-Key of the user to be blinded) rsa

  • serverIDsigner blind signs m' rsa

  • user can unblind m, to get m signed rsa

  • This works because RSA keys satisfy this equation rsa and this rsa

4.- Conclusions

  • This is just a proof of concept, as an extra project in a university small subject. Is not a full finalized project.
  • Cryptographic blind signature is very powerful, and also, can be combined with homomorphic encryption properties, to make secure and anonymous systems.
  • In this proof of concept, the smart contract integration is not finished, and is using ethereum Smart Contracts, but can be implemented using any other blockchain technology. At the beginning I tried to implement a complete p2p network and a blockchain from scratch (but was not a good idea having a short amount of time).
  • A decentralized anonymized login system over blockchain, can have lots of applications for example, can be useful to authentication for centralized and decentralized platforms, for voting systems, for health systems, for exchanges, for anonymous reputation systems, etc.

More Repositories

1

coffeeMiner

collaborative (mitm) cryptocurrency mining pool in wifi networks
Python
1,057
star
2

go-snark-study

zkSNARK library implementation in Go from scratch (compiler, setup, prover, verifier)
Go
232
star
3

cryptofun

Crypto algorithms from scratch in Go. Learning purposes only. ECC, BN128 pairing, Paillier, RSA, Homomorphic computation, ElGamal, Schnorr, ECDSA, BLS, ...
Go
68
star
4

flock-botnet

Twitter botnet with autonomous bots replying tweets with text generated based on probabilities in Markov chains
Go
55
star
5

awesome-circom

A curated list of repos related to Circom
53
star
6

poseidon-rs

Poseidon hash function
Rust
40
star
7

goBlockchainDataAnalysis

blockchain data analysis
Go
36
star
8

provoj

Simple python library to check the endpoints of an RESTful API
Python
35
star
9

protogalaxy-poc

ProtoGalaxy folding scheme PoC implementation https://eprint.iacr.org/2023/1106.pdf
Rust
31
star
10

evm-rs

Ethereum Virtual Machine implementation from scratch in Rust
Rust
24
star
11

babyjubjub-rs

BabyJubJub elliptic curve implementation in Rust
Rust
24
star
12

kzg-commitments-study

Kate-Zaverucha-Goldberg Polynomial Commitments
Go
23
star
13

miksi-core

ethereum zk coin-mixer
Solidity
19
star
14

goDDOS

academical ddos server client written in go
Go
17
star
15

shamirsecretsharing

ShamirSecretSharing Rust & Go implementation + WASM lib
Rust
16
star
16

merkletree-rs

Sparse MerkleTree implementation in Rust
Rust
16
star
17

go-blindsecp256k1

Blind signatures over secp256k1 elliptic curve
Go
12
star
18

go-bellman-verifier

Groth16 zkSNARK bellman proof verifier using cloudflare/bn256 Pairing
Go
11
star
19

goNmapTelegramBot

simple telegram bot, that gets an ip, performs a nmap port scan, and returns the result to the telegram user
Go
9
star
20

eth-kzg-ceremony-alt

Alternative implementation of the contributor-client for the Ethereum KZG Trusted Setup Ceremony
Go
9
star
21

go-dht

Kademlia DHT implementation
Go
8
star
22

mimc-rs

MiMC hash function
Rust
7
star
23

blogo

Static blog generator, template engine from markdown and html templates
Go
7
star
24

argos

Open source twitter entropic toolkit written in Go lang
Go
7
star
25

gogame

Nostalgic OGame clone in Go
Go
7
star
26

commonroutesApp

car sharing app - client side [Angularjs + Ionic]
JavaScript
6
star
27

class2context

javascript library, to add context menu functionallity to html page
JavaScript
6
star
28

decentralized-blogging-platform

Decentralized blogging platform, over IPFS
HTML
6
star
29

go-merkletree-old

Optimized MerkleTree implementation in Go.
Go
6
star
30

echo-botnet

A twitter botnet with autonomous bots replying tweets with pre-configured replies
Go
5
star
31

fri-commitment

FRI commitment scheme
Rust
5
star
32

link2epub

Very simple tool to download articles and convert it to .epub/.mobi files.
Go
5
star
33

blindsecp256k1-js

Typescript implementation of blind signatures over secp256k1 compatible with https://github.com/arnaucube/go-blindsecp256k1
TypeScript
4
star
34

fft-rs

Fast Fourier Transform implementation in Rust
Rust
4
star
35

slowlorisdb

Slow, decentralized and cryptographically consistent database
Go
3
star
36

galdric

machine learning server, for image classification applying KNN
Go
3
star
37

huffman-coding

Huffman encoding and decoding
Go
3
star
38

wifiAutoWPS

auto wps pin for wifi code adaption
Shell
3
star
39

commonroutesServer

car sharing app - backend
JavaScript
3
star
40

miksi-app

JavaScript
2
star
41

configs

config files
Shell
2
star
42

gogame-frontend

Frontend for https://github.com/arnaucube/gogame
JavaScript
2
star
43

faircoinmap-webapp

Webapp map showing places accepting FairCoin
JavaScript
2
star
44

go-chip8

CHIP-8 emulator written in Go
Go
2
star
45

bc

Own p2p network and own blockchain libraries written in Go, to develop own decentralized apps.
Go
2
star
46

goCaptcha

captcha server, with own datasets
Go
2
star
47

md-live-server

Server that renders markdown files and live updates the page each time that the file is updated
Go
2
star
48

commonroutesBot

Telegram bot to notify when new travels are published.
JavaScript
2
star
49

pad2ipfs

Simply Go lang library to get the content from a pad (etherpad) and put into IPFS.
Go
2
star
50

math

Notes, code and documents done while reading books and papers.
TeX
2
star
51

goImgServer

Server of images, written in Go lang
Go
2
star
52

padArchiver

Tool to store pads (from url) into local directory and IPFS.
Go
2
star
53

blockchainIDsystem

Blockchain based anonymous distributed ID system
Go
2
star
54

esp32-wallet-viewer

esp32 code to monitor wallets
C
2
star
55

slides

Go
1
star
56

blog

JavaScript
1
star
57

mumble-telegram-bot

Telegram bot that sends messages when users connect, move from rooms, and disconnect from the Mumble (Murmur) server.
JavaScript
1
star
58

ring-signatures-rs

bLSAG implementation in rust
Rust
1
star
59

commonroutesLandingPage

CSS
1
star
60

twitterReader

twitter reader assistant
Go
1
star
61

raspberryGPIOhtmlserver

[nodejs + express + pi-gpio] nodejs server to control raspberrypi GPIO, from an html server
JavaScript
1
star
62

tor-eth-online-shop

HTML
1
star
63

blindsig-client-server-example

Example of usage of https://github.com/arnaucube/go-blindsecp256k1
JavaScript
1
star
64

paraulogic-word-finder

Python
1
star
65

blogoExample

This is an example of the use of blogo static blog engine (https://github.com/arnaucube/blogo).
HTML
1
star
66

kesto

box with pieces of code
Go
1
star
67

ipa-rs

modified Inner Product Argument version from Halo paper
Rust
1
star
68

goRecommender

Content recommendation API based on Machine Learning
Go
1
star
69

nokto

xfce terminal theme
1
star
70

chip8-rs

CHIP-8 emulator written in Rust
Rust
1
star
71

faircoin-calculator

very simple Faircoin calculator
HTML
1
star
72

goKNN

Go library of the K Nearest Neighbors algorithm, calculating the Euclidean distances
Go
1
star
73

kindle-weather

CSS
1
star
74

botnetCrafter

Python
1
star
75

cellMapVisualizer

Data analyisis server & Web map visualization for a dataset of more than 3.5GB
Go
1
star