Displaying 1 to 20 from 23 results

keytransparency - A transparent and secure way to look up public keys.

  •    Go

Key Transparency provides a lookup service for generic records and a public, tamper-proof audit log of all record changes. While being publicly auditable, individual records are only revealed in response to queries for specific IDs.Key Transparency can be used as a public key discovery service to authenticate users and provides a mechanism to keep the service accountable. It can be used by account owners to reliably see what keys have been associated with their account, and it can be used by senders to see how long an account has been active and stable before trusting it.

trillian - Trillian implements a Merkle tree whose contents are served from a data storage layer, to allow scalability to extremely large trees

  •    Go

Trillian is an implementation of the concepts described in the Verifiable Data Structures white paper, which in turn is an extension and generalisation of the ideas which underpin Certificate Transparency.Note that Trillian requires particular applications to provide their own personalities on top of the core transparent data store functionality; example code for a certificate transparency log and for a log-derived map are included to help with this.

immudb - world’s fastest immutable database

  •    Go

immudb is a database with built-in cryptographic proof and verification. It can track changes in sensitive data and the integrity of the history will be protected by the clients, without the need to trust the server. It can operate as a key-value store or as relational database (SQL).

QRL - Quantum Resistant Ledger

  •    Python

Python-based blockchain ledger utilizing hash-based one-time merkle tree signature scheme (XMSS) instead of ECDSA. Proof-of-work block selection via the cryptonight algorithm. Future transition to POS with signed iterative hash chain reveal scheme which is both probabilistic and random (https://github.com/theQRL/pos). Hash-based signatures means larger transactions (3kb per tx, binary), longer keypair generation times and the need to record 'state' of transactions as each keypair can only be used once safely. Merkle tree usage enables a single address to be used for signing numerous transactions (up to 2^13 computationally easily enough). Currently XMSS/W-OTS+ are natively supported with extensible support for further cryptographic schemes inbuilt.

merkletree - A Merkle Tree implementation written in Go.

  •    Go

An implementation of a Merkle Tree written in Go. A Merkle Tree is a hash tree that provides an efficient way to verify the contents of a set data are present and untampered with.At its core, a Merkle Tree is a list of items representing the data that should be verified. Each of these items is inserted into a leaf node and a tree of hashes is constructed bottom up using a hash of the nodes left and right children's hashes. This means that the root node will effictively be a hash of all other nodes (hashes) in the tree. This property allows the tree to be reproduced and thus verified by on the hash of the root node of the tree. The benefit of the tree structure is verifying any single content entry in the tree will require only nlog2(n) steps in the worst case.

exonum-client - JavaScript client for Exonum blockchain

  •    Javascript

Compatible with Exonum v0.5. A JavaScript library to work with Exonum blockchain from browser and Node.js. Used to sign transactions before sending to blockchain and verify blockchain responses using cryptographic proofs. Contains numerous helper functions.

gb_merkle_trees - General balanced binary Merkle trees for Erlang

  •    Erlang

An Erlang library that provides a dictionary-like storage for binaries using general balanced binary Merkle trees, with an interface similar to gb_trees. This library uses semantic versioning 2.0. If a change causes different root hashes to be generated for the same input data when entering or deleting, it is considered backwards incompatible.

merkle-generator - generate a merkle tree based on incoming data

  •    Rust

Rust version of mafintosh/merkle-tree-stream. Generate a merkle tree based on incoming data. See mafintosh/flat-tree-rs for more information about how node/parent indexes are calculated.

smt - A Go library that implements a Sparse Merkle tree for a key-value map.

  •    Go

A Go library that implements a Sparse Merkle tree for a key-value map. Thanks to Vitalik Buterin who provided the original Python prototype that some of this library is inspired from.

merkle - Merkle root algorithms in various languages

  •    C

Merkle root algorithms in various languages. A Merkle tree is a tree of hashes. Each node is formed by hashing the concatenation of the nodes below it. The leaves are formed by splitting the input data into segments and hashing each segment. The Merkle root is the root node of such a tree.

merkle_tree - :evergreen_tree: Merkle Tree implementation in pure Elixir

  •    Elixir

Merkle Tree implementation in pure Elixir. Install the Elixir functional language.

chainpoint-services - A microservices architecture for anchoring hashes to the blockchain at scale.

  •    Javascript

Chainpoint Services is at the Core of the Tierion Network and built as a modern microservices architecture. The services provided are generally composed of Node.js applications running within Alpine Linux Docker containers. These containers, while intended to be run within a full Docker orchestration system such as Kubernetes in production, run well on a single host using Docker Compose. This run method is suitable for development only.

yggdrasill - Block storage(Blockchain) library that supports custom blocks and transactions

  •    Go

Yggdrasill is a block storage(Blockchain) library that supports custom blocks and transactions. Define the custom block struct you want! If you implement a block interface, any struct of block can be easily verified and stored in a Block storage(Blockchain). Yggdrasill source code files are made available under the Apache License, Version 2.0 (Apache-2.0), located in the LICENSE file.

coniks-go - A CONIKS implementation in Golang

  •    Go

CONIKS is a key management system that provides transparency and privacy for end-user public keys. CONIKS protects end-to-end encrypted communications against malicious or compromised communication providers and surveillance by storing users' encryption keys in tamper-evident and publicly auditable key directories on the server side. This allows messaging clients to verify the identity of users automatically, and prevents malicious/compromised servers from hijacking secure communications without getting caught. This repository provides a Golang implementation of the CONIKS system. The implementation consists of a library, described in the following section, a standalone CONIKS-server and -client, and a registration proxy using this library.

coniks-java - A CONIKS implementation in Java

  •    Java

CONIKS is a key management system that provides transparency for end-user public keys.

qed - quod erat demonstrandum - verifiable data structure

  •    Go

qed is a software to test the scalability of authenticated data structures. Our mission is to design a system which, even when deployed into a non-trusted server, allows one to verify the integrity of a chain of events and detect modifications of single events or parts of its history. This software is experimental and part of the research being done at BBVA Labs. We will eventually publish our research work, analysis and the experiments for anyone to reproduce.

iavl - Merkleized IAVL+ Tree implementation in Go

  •    Go

A versioned, snapshottable (immutable) AVL+ tree for persistent data. The purpose of this data structure is to provide persistent storage for key-value pairs (say to store account balances) such that a deterministic merkle root hash can be computed. The tree is balanced using a variant of the AVL algorithm so all operations are O(log(n)).

auth-adt - Authenticated Data Structures Generically

  •    Haskell

Derive inclusion and membership proofs for arbitrary sum-of-product datatypes in Haskell using GHC.Generics. Authenticated data structures (ADS) allow untrusted parties (provers) answer queries on a data structures on behalf of a trusted source (verifier) and provide a compact proof of the computation. A verifier can then efficiently check the authenticity of the answer.

We have large collection of open source products. Follow the tags from Tag Cloud >>

Open source products are scattered around the web. Please provide information about the open source projects you own / you use. Add Projects.