Popularity
8.4
Growing
Activity
8.9
Growing
1,494
80
143

Description

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.

Programming language: Go
Latest version: v0.2.0-rc.1

Key Transparency alternatives and similar packages

Based on the "Server Applications" category

Do you think we are missing an alternative of Key Transparency or a related project?

Add another 'Server Applications' Package

README

Key Transparency

GoDoc Build Status Go Report Card codecov

[Key Transparency Logo](docs/images/logo.png)

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.

Key Transparency empowers account owners to [reliably see](docs/verification.md) what public 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.

Key Transparency can add [verifiable](docs/verification.md) and user-friendly auditing to any [scenario](docs/scenarios.md) that involves authenticating users with public keys, including Universal Second Factor Security Keys and end-to-end encryption.

  • [Overview](docs/overview.md)
  • [Design document](docs/design.md)
  • [API](docs/api.md)

Objective

Key Transparency aims to make key management in the context of end-to-end encryption secure and user friendly. The current status-quo of many consumer products gives the service provider (the server) the power to redirect messages to unintended recipients, even if the product uses end-to-end encryption, because the first step of sending a message requires the sender to ask the server to provide the correct encryption key for the recipient. Simply put, servers can lie about the identity of your friends. If users never forgot their passwords, private keys, reinstalled apps, and never changed phones it would be easy to meet once in-person with every contact to establish a secure identity, but in practice, users change keys regularly.

What Key Transparency Does

  • Key Transparency allows users to recover their accounts with the assistance of the server.
  • Key Transparency gives users the power to know, with certainty, about all the public keys that have ever been in their account, preventing the server from making changes to user accounts without detection.

Project Status

Key Transparency is a work-in-progress with the following milestones under development.

Key Transparency Client

Setup

  1. Install Go 1.13.
  2. GO111MODULE=on go get github.com/google/keytransparency/cmd/keytransparency-client

Client operations

View a Directory's Public Keys

The Key Transparency server publishes a separate set of public keys for each directory that it hosts. By hosting multiple directories, a single domain can host directories for multiple apps or customers. A standardized pattern for discovering domains and directories is a TODO in issue #389.

Within a directory the server uses the following public keys to sign its responses:

  1. log.public_key signs the top-most Merkle tree root, covering the ordered list of map roots.
  2. map.public_key signs each snapshot of the key-value database in the form of a sparse Merkle tree.
  3. vrf.der signs outputs of the Verifiable Random Function which obscures the key values in the key-value database.

A directory's public keys can be retrieved over HTTPS/JSON with curl or over gRPC with grpcurl. The sandboxserver has been initialized with a domain named default.

$ curl -s https://sandbox.keytransparency.dev/v1/directories/default | json_pp
$ grpcurl -d '{"directory_id": "default"}' sandbox.keytransparency.dev:443 google.keytransparency.v1.KeyTransparency/GetDirectory

Show output

{
   "directory_id" : "default",
   "log" : {
      "hash_algorithm" : "SHA256",
      "hash_strategy" : "RFC6962_SHA256",
      "public_key" : {
         "der" : "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXPi4Ut3cRY3OCXWvcSnE/sk6tbDEgBeZapfEy/BIKfsMbj3hPLG+WEjzh1IP2TDirc9GpQ+r9HVGR81KqRpbjw=="
      },
      "signature_algorithm" : "ECDSA",
      "tree_id" : "4565568921879890247",
      "tree_type" : "PREORDERED_LOG"
   },
   "map" : {
      "hash_algorithm" : "SHA256",
      "hash_strategy" : "CONIKS_SHA256",
      "public_key" : {
         "der" : "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgX6ITeFrqLmclqH+3XVhbaEeJO37vy1dZYRFxpKScERdeeu3XRirJszc5KJgaZs0LdvJqOccfNc2gJfInLGIuA=="
      },
      "signature_algorithm" : "ECDSA",
      "tree_id" : "5601540825264769688",
      "tree_type" : "MAP"
   },
   "max_interval" : "60s",
   "min_interval" : "1s",
   "vrf" : {
      "der" : "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvuqCkY9rM/jq/8hAoQn2PClvlNvVeV0MSUqzc67q6W+MzY/YZKmPLY5t/n/VUEqeSgwU+/sXgER3trsL6nZu+A=="
   }
}

Generate Update Signing Keys

Every update to a user record in key transparency must be signed by an authorized-key.

Update signatures are saved in the Merkle tree data structure, producing a record of who made each change to a user's account, allowing products to distinguish between changes signed by a user key, the provider's key, or a reset-provider's key.

Each account has an updatable policy that lists the current set of authorized public keys that are allowed to make updates to the user's record.

To create an initial set of update signing keys, run the authorized-keys create-keyset command. Keys will be saved in a .keyset file in the current working directory.

$ PASSWORD=[[YOUR-KEYSET-PASSWORD]]
$ keytransparency-client authorized-keys create-keyset --password=${PASSWORD}

Show output

$ PASSWORD=[[YOUR-KEYSET-PASSWORD]]
$ keytransparency-client authorized-keys create-keyset --password=${PASSWORD}
$ keytransparency-client authorized-keys list-keyset --password=${PASSWORD}
My Authorized Keys:
primary_key_id:17445529 key_info:<type_url:"type.googleapis.com/google.crypto.tink.EcdsaPrivateKey" status:ENABLED key_id:17445529 output_prefix_type:TINK >

Publish the public key

Any number of protocols may be used to prove to the server that a client owns a userID. The sandbox server supports a fake authentication string and OAuth.

Create or fetch the public key for your specific application.

   openssl genpkey -algorithm X25519 -out xkey.pem
   openssl pkey -in xkey.pem -pubout
   -----BEGIN PUBLIC KEY-----
   MCowBQYDK2VuAyEAtCAsIMDyVUUooA5yhgRefcEr7edVOmyNCUaN1LCYl3s=
   -----END PUBLIC KEY-----
  keytransparency-client post user@domain.com \
  --kt-url sandbox.keytransparency.dev:443 \
  --fake-auth-userid user@domain.com \
  --password=${PASSWORD} \
  --verbose \
  --logtostderr \
  --data='MCowBQYDK2VuAyEAtCAsIMDyVUUooA5yhgRefcEr7edVOmyNCUaN1LCYl3s=' #Your public key in base64

Get and verify a public key

  keytransparency-client get <email> --kt-url sandbox.keytransparency.dev:443 --verbose
  ✓ Commitment verified.
  ✓ VRF verified.
  ✓ Sparse tree proof verified.
  ✓ Signed Map Head signature verified.
  CT ✓ STH signature verified.
  CT ✓ Consistency proof verified.
  CT   New trusted STH: 2016-09-12 15:31:19.547 -0700 PDT
  CT ✓ SCT signature verified. Saving SCT for future inclusion proof verification.
  ✓ Signed Map Head CT inclusion proof verified.
  keys:<key:"app1" value:"test" >

Verify key history

  keytransparency-client history user@domain.com --kt-url sandbox.keytransparency.dev:443
  Revision |Timestamp                    |Profile
  4        |Mon Sep 12 22:23:54 UTC 2016 |keys:<key:"app1" value:"test" >

Checks

Running the server

  1. OpenSSL
  2. Docker
    • Docker Engine 1.17.6+ docker version -f '{{.Server.APIVersion}}'
    • Docker Compose 1.11.0+ docker-compose --version
go get github.com/google/keytransparency/...
go get github.com/google/trillian/...
cd $(go env GOPATH)/src/github.com/google/keytransparency
./scripts/prepare_server.sh -f
docker-compose -f docker-compose.yml docker-compose.prod.yml up
  1. Watch it Run
  2. Proof for foo@bar.com
  3. Server configuration info

Development and Testing

Key Transparency and its Trillian backend use a MySQL database, which must be setup in order for the Key Transparency tests to work.

docker-compose up -d db will launch the database in the background.

Directory structure

The directory structure of Key Transparency is as follows:

  • [cmd](cmd): binaries
    • [keytransparency-client](cmd/keytransparency-client): Key Transparency CLI client.
    • [keytransparency-sequencer](cmd/keytransparency-sequencer): Key Transparency backend.
    • [keytransparency-server](cmd/keytransparency-sequencer): Key Transparency frontend.
  • [core](core): main library source code. Core libraries do not import [impl](impl).
    • [adminserver](core/adminserver): private API for creating new directories.
    • [api](core/api): gRPC API definitions.
    • [crypto](core/crypto): verifiable random function and commitment implementations.
    • [directory](core/directory): interface for retrieving directory info from storage.
    • [keyserver](core/keyserver): keyserver implementation.
    • [mutator](core/mutator): "smart contract" implementation.
    • [sequencer](core/sequencer): mutation executor.
  • [deploy](deploy): deployment configs:
    • [docker](deploy/docker): init helper.
    • [kubernetes](deploy/kubernetes): kube deploy configs.
    • [prometheus](deploy/prometheus): monitoring docker module.
  • [docs](docs): documentation.
  • [impl](impl): environment specific modules:
    • [authentication](impl/authentication): authentication policy grpc interceptor.
    • [authorization](impl/authorization): OAuth and fake auth grpc interceptor.
    • [integration](impl/integration): environment specific integration tests.
    • [sql](impl/sql): mysql implementations of storage modules.
  • [scripts](scripts): scripts
    • [deploy](scripts/deploy.sh): deploy to Google Compute Engine.

Support

Acknowledgements

Key Transparency would not have been possible without a whole host of collaborators including researchers, interns, and open source contributors.

Key Transparency was inspired by CONIKS and Certificate Transparency.