• Stars
    star
    205
  • Rank 184,066 (Top 4 %)
  • Language
    C++
  • License
    Other
  • Created almost 11 years ago
  • Updated about 7 years ago

Reviews

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

Repository Details

Web Cryptography API Polyfill

NOTE: THIS PROJECT IS NO LONGER UNDER ACTIVE MAINTAINENCE. With most browsers now providing W3C Web Crypto implementations and Chrome disallowing 3rd-party PPAPI plugins, there is little use for this project. It will remain here on Github indefinitely, but there are no plans to keep any branch updated. The most recent code lives in the 'newInterface' branch.

Netflix WebCrypto (NfWebCrypto)

Netflix WebCrypto is a polyfill of the W3C Web Cryptography API, 22 April 2013 Editor's Draft, as a native Chrome PPAPI plugin. Unlike a javascript polyfill, the native implementation supports a stronger security model with no key material exposed to javascript. The goal is to make the Web Crypto Javascript API freely available to web developers for experimentation and use prior to its implementation by browser vendors.

Currently only Google Chrome / Chromium on linux amd64 is supported.

Features

NfWebCrypto does not implement the Web Crypto API in its entirety, due to limitations of browser plugin technology and initial focus on operations and algorithms most useful to Netflix. However, the existing feature set supports many typical and common crypto use cases targeted by the Web Crypto API.

Supported

  • Interfaces supported:
    • Key, KeyPair
    • KeyOperation
    • CryptoOperation
    • CryptoKeys
  • SubtleCrypto interface methods supported
    • encrypt, decrypt
    • sign, verify
    • generateKey
    • exportKey, importKey
    • wrapKey, unwrapKey* **
  • CryptoKeys interface methods supported
    • getKeyByName
  • Key formats supported
    • symmetric keys: raw and jwk (raw)
    • asymmetric keys: pkcs#8 (public), spki (private), and jwk (public only)
  • Algorithms supported
    • SHA-1, SHA-224, SHA-256, SHA-384, SHA-512: digest
    • HMAC SHA-256: sign, verify, importKey, exportKey, generateKey
    • AES-128 CBC w/ PKCS#5 padding: encrypt, decrypt, importKey, exportKey, generateKey
    • RSASSA-PKCS1-v1_5: sign, verify, importKey, generateKey
    • RSAES-PKCS1-v1_5: encrypt, decrypt, importKey, exportKey, generateKey
    • Diffie-Hellman: generateKey, deriveKey
    • RSA-OAEP: wrapKey, unwrapKey
    • AES-KW: wrapKey, unwrapKey
    • AES-GCM: encrypt, decrypt, importKey, exportKey, generateKey

*A special "Kds" NamedKey bound to the plugin binary and script origin can be used with (un)wrapKey to export/import opaque key representations for persistence in HTML5 local storage or equivalent.

**Wrap/Unwrap operations follow the Netflix KeyWrap Proposal and support protection of the JWE payload with AES128-GCM. It is be possible to wrap/unwrap the following key types: HMAC SHA-256 and AES-128 CBC.

Not Supported

  • The streaming/progressive processing model in not supported
  • Synchronous API's like getRandomValues() are not supported
  • Algorithm normalizing rules are not fully implemented

Moving forward, Netflix will continue to enhance this implementation and try to keep it as much in sync as possible with the latest draft Web Crypto API spec.

Requirements

Linux

  • Ubuntu 12.04 64-bit with build-essential, libssl-dev-1.0.1c or later, and cmake 2.8 or later
  • 64-bit Google Chrome / Chromium R22 or later (tested with R27)

Directory Tour

base/
    Common C++ source for both the plugin and crypto component.
cmake/
    Cmake toolchain files.
    Linux desktop builds use the linux system build tools and libs.
    Only 64-bit builds are supported for now.
crypto/
    C++ source for the crypto component. The contents of this directory is
    of primary interest to native devs; the entry point is the CadmiumCrypto
    class. This directory currently builds to an archive file.
crypto/test/
    Contains C++ gtest unit tests that exercise the CadmiumCrypto class
    interface. Not fleshed out yet and currently not built.
misc/
    Miscellaneous code to support development. Currently has code to run and
    debug the Chrome browser with the plugin properly registered.
plugin/
    C++ source of the PPAPI plugin. This code builds to shared library that
    is dl-loaded by the browser when the plugin is registered. It handles
    interfacing with the browser, bridging to the crypto thread, and decode/
    dispatch of JSON messages to and from the browser. Native devs will
    probably only be interested in the NativeBridge class here.
web/nfcrypto.js
    The javascript front-end for the plugin. The bottom level of this code
    handles the transport of JSON-serialized messages to and from the
    plugin, while the top level implements the W3C WebCrypto interface.
    Native devs will need to change the bottom level to match their bridge
    API. This source file borrows heavily from PolyCrypt (polycrypt.net)
web/test_qa.html
    The Jasmine HTML unit tests that exercise the javascript WebCrypto
    API exposed to the javascript client by nfcrypto.js.

How to Build

The following has been verified on Ubunutu 12.04. cmake 2.8 or later is required.

NOTE: The SYSTEM key mentioned above depends in part on a secret build-time key SECRET_SYSTEM_KEY that for example purposes is hard-coded in linux_common.cmake. Actual deployments must change this key.

$ mkdir buildDir
$ cd buildDir
$ cmake -DCMAKE_TOOLCHAIN_FILE=(repo)/cmake/toolchains/linux64.cmake -DCMAKE_BUILD_TYPE=[Debug|Release] (repo)
$ make -j<N>

Build Results

Browser plugin - This is registered and run within the Chrome browser.

(buildDir)/plugin/libnfwebcrypto.so
(buildDir)/plugin/nfwebcrypto.info

Native gtest unit test executable (if built). This is run from the command line.

(buildDir)/crypto/test/test

Native CadmiumCrypto archive. Native apps will link to this archive.

(buildDir)/crypto/libcadcrypto.a

How to run the Unit Tests

Chrome must be run with a special command line option to register the plugin. The easiest way to do this is to use the provided start.sh script, which employs the .info file generated by the build.

Make a directory and copy or symlink start.sh, libnfwebcrypto.so, and nfwebcrypto.info.

$ mkdir runNfWebCrypto
$ cd !$
$ ln -s (repo)/misc/desktop/start.sh
$ ln -s (buildDir)/plugin/libnfwebcrypto.so
$ ln -s (buildDir)/plugin/nfwebcrypto.info

The start.sh script depends on the chrome executable present at /opt/google/chrome/chrome. Edit the script if this is not true. Finally, start chrome and run the unit tests hosted on github by running the script.

$ ./start.sh

Note that there must not be any other chrome instance running in the system before the script is executed. Otherwise the action will be to just open a new tab on the existing instance without loading the plugin.

The unit tests will run automatically and all should pass.

Sample Code

Here are some examples of how to use the Web Cryptography API to perform typical crypto operations. These will work once the plugin is installed and enabled. More detailed usage examples may be found in the javascript unit tests.

The examples below use the following utility functions to convert between string and Uint8Array:

// string to uint array
function text2ua(s) {
    var escstr = encodeURIComponent(s);
    var binstr = escstr.replace(/%([0-9A-F]{2})/g, function(match, p1) {
        return String.fromCharCode('0x' + p1);
    });
    var ua = new Uint8Array(binstr.length);
    Array.prototype.forEach.call(binstr, function (ch, i) {
        ua[i] = ch.charCodeAt(0);
    });
    return ua;
}

// uint array to string
function ua2text(ua) {
    var binstr = Array.prototype.map.call(ua, function (ch) {
        return String.fromCharCode(ch);
    }).join('');
    var escstr = binstr.replace(/(.)/g, function (m, p) {
        var code = p.charCodeAt(p).toString(16).toUpperCase();
        if (code.length < 2) {
            code = '0' + code;
        }
        return '%' + code;
    });
    return decodeURIComponent(escstr);
}

Compute SHA-1 hash

<script src='nfcrypto.js'></script>
<script>
    var cryptoSubtle = window.nfCrypto.subtle;
    var data = "This is some data to hash";    
    var op = cryptoSubtle.digest({ name: "SHA-1" }, text2ua(data));
    op.oncomplete = function (e) {
        window.alert("SHA-1 of \"" + data + "\": " + btoa(e.target.result));
    };
</script>

AES-CBC Encryption / Decryption

<script src='nfcrypto.js'></script>
<script>

    var cryptoSubtle = window.nfCrypto.subtle;
    var cleartext = "This is some cleartext to encrypt.";
    var key;
    var iv = new Uint8Array([0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                             0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F]);
    var ciphertext;
    
    // generate a non-extractable 128-bit AES key
    function generateKey() {
        var genKeyOp = cryptoSubtle.generateKey(
            { name: "AES-CBC", params: { length: 128 } },
            false
        );
        genKeyOp.oncomplete = function (e) {
            key = e.target.result;
            encryptData();
        }
    }
    
    // encrypt cleartext to get ciphertext
    function encryptData() {
        var encOp = cryptoSubtle.encrypt({
            name: "AES-CBC",
            params: { iv: iv }
        }, key, text2ua(cleartext));
        encOp.oncomplete = function (e) {
            cipherText = e.target.result;
            decryptData();
        }
    }
    
    // decrypt ciphertext to get cleartext
    function decryptData() {
        var encOp = cryptoSubtle.decrypt({
            name: "AES-CBC",
            params: { iv: iv }
        }, key, cipherText);
        encOp.oncomplete = function (e) {
            var cleartext2 = ua2text(e.target.result);
            if (cleartext2.valueOf() == cleartext.valueOf()) {
                window.alert("Round-trip encryption/decryption works!");
            }
        }
    }

    generateKey();

</script>

Sign / Verify Data with HMAC SHA256

<script src='nfcrypto.js'></script>
<script>

    var cryptoSubtle = window.nfCrypto.subtle;
    var data = "This is some data to sign",
        hmacKey,
        signature;

    function generateKey() {
        var genOp = cryptoSubtle.generateKey({ name: "HMAC", params: { hash: {name: "SHA-256"} } });
        genOp.oncomplete = function (e) {
            hmacKey = e.target.result;
            signData();
        };
    }
    
    function signData() {
        var signOp = cryptoSubtle.sign(
            { name: "HMAC", params: { hash: "SHA-256" } },
            hmacKey,
            text2ua(data)
        );
        signOp.oncomplete = function (e) {
            signature = e.target.result;
            verifyData();
        };
    }
    
    function verifyData() {
        var verifyOp = cryptoSubtle.verify(
            { name: "HMAC", params: { hash: "SHA-256" } },
            hmacKey,
            signature,
            text2ua(data)
        );
        verifyOp.oncomplete = function (e) {
            if (e.target.result) {
                window.alert("Round-trip hmac sign/verify works!");
            }
        };
    }

    generateKey();
    
</script>

RSA Encryption / Decryption

<script src='nfcrypto.js'></script>
<script>

    var cryptoSubtle = window.nfCrypto.subtle;
    var clearText = "This is some data to encrypt";
    var pubKey, privKey;
    var cipherText;
    
    // generate a 1024-bit RSA key pair for encryption
    function generateKey() {
        var genOp = cryptoSubtle.generateKey({
            name: "RSAES-PKCS1-v1_5",
            params: {
                modulusLength: 1024,
                publicExponent: new Uint8Array([0x01, 0x00, 0x01]) // Fermat F4
            }
        }, false);
        genOp.oncomplete = function (e) {
            pubKey  = e.target.result.publicKey;
            privKey = e.target.result.privateKey;
            exportKey();
        }
    }
    
    // export the public key in SPKI format in order to send it to the peer
    function exportKey() {
        var exportOp = cryptoSubtle.exportKey("spki", pubKey);
        exportOp.oncomplete = function (e) {
            var pubKeySpki = e.target.result;
            // here you would send pubKeySpki to peer
            encryptData();
        }
    }
    
    // simulate peer encryption by encrypting clearText with the public key
    function encryptData() {
        var encryptOp = cryptoSubtle.encrypt(
            { name: "RSAES-PKCS1-v1_5" },
            pubKey,
            text2ua(clearText)
        );
        encryptOp.oncomplete = function (e) {
            cipherText = e.target.result;
            decryptData();
        }
    }
    
    // pretend the cipherText was received from the peer, and decrypt it
    // with the private key; should get the same clearText back
    function decryptData() {
        var decryptOp = cryptoSubtle.decrypt({ name: "RSAES-PKCS1-v1_5" }, privKey, cipherText);
        decryptOp.oncomplete = function (e) {
            var clearText2 = ua2text(e.target.result);
            if (clearText2.valueOf() == clearText.valueOf()) {
                window.alert("Round-trip RSA encrypt/decrypt successful!");
            }
        }
    }
    
    generateKey();
    
</script>

More Repositories

1

Hystrix

Hystrix is a latency and fault tolerance library designed to isolate points of access to remote systems, services and 3rd party libraries, stop cascading failure and enable resilience in complex distributed systems where failure is inevitable.
Java
23,594
star
2

chaosmonkey

Chaos Monkey is a resiliency tool that helps applications tolerate random instance failures.
Go
14,410
star
3

zuul

Zuul is a gateway service that provides dynamic routing, monitoring, resiliency, security, and more.
Java
12,993
star
4

conductor

Conductor is a microservices orchestration engine.
Java
12,920
star
5

eureka

AWS Service registry for resilient mid-tier load balancing and failover.
Java
11,991
star
6

falcor

A JavaScript library for efficient data fetching
JavaScript
10,338
star
7

pollyjs

Record, Replay, and Stub HTTP Interactions.
JavaScript
10,184
star
8

SimianArmy

Tools for keeping your cloud operating in top form. Chaos Monkey is a resiliency tool that helps applications tolerate random instance failures.
Java
7,955
star
9

metaflow

๐Ÿš€ Build and manage real-life ML, AI, and data science projects with ease!
Python
7,498
star
10

fast_jsonapi

No Longer Maintained - A lightning fast JSON:API serializer for Ruby Objects.
Ruby
5,078
star
11

dispatch

All of the ad-hoc things you're doing to manage incidents today, done for you, and much more!
Python
4,548
star
12

ribbon

Ribbon is a Inter Process Communication (remote procedure calls) library with built in software load balancers. The primary usage model involves REST calls with various serialization scheme support.
Java
4,468
star
13

security_monkey

Security Monkey monitors AWS, GCP, OpenStack, and GitHub orgs for assets and their changes over time.
Python
4,349
star
14

vmaf

Perceptual video quality assessment based on multi-method fusion.
Python
4,159
star
15

dynomite

A generic dynamo implementation for different k-v storage engines
C
4,104
star
16

vizceral

WebGL visualization for displaying animated traffic graphs
JavaScript
4,047
star
17

vector

Vector is an on-host performance monitoring framework which exposes hand picked high resolution metrics to every engineerโ€™s browser.
JavaScript
3,588
star
18

atlas

In-memory dimensional time series database.
Scala
3,331
star
19

concurrency-limits

Java
3,117
star
20

consoleme

A Central Control Plane for AWS Permissions and Access
Python
3,065
star
21

flamescope

FlameScope is a visualization tool for exploring different time ranges as Flame Graphs.
Python
2,979
star
22

dgs-framework

GraphQL for Java with Spring Boot made easy.
Kotlin
2,963
star
23

bless

Repository for BLESS, an SSH Certificate Authority that runs as a AWS Lambda function
Python
2,722
star
24

archaius

Library for configuration management API
Java
2,435
star
25

asgard

[Asgard is deprecated at Netflix. We use Spinnaker ( www.spinnaker.io ).] Web interface for application deployments and cloud management in Amazon Web Services (AWS). Binary download: http://github.com/Netflix/asgard/releases
Groovy
2,235
star
26

curator

ZooKeeper client wrapper and rich ZooKeeper framework
Java
2,138
star
27

titus

1,996
star
28

EVCache

A distributed in-memory data store for the cloud
Java
1,900
star
29

lemur

Repository for the Lemur Certificate Manager
Python
1,651
star
30

bpftop

bpftop provides a dynamic real-time view of running eBPF programs. It displays the average runtime, events per second, and estimated total CPU % for each program.
Rust
1,647
star
31

genie

Distributed Big Data Orchestration Service
Java
1,635
star
32

metacat

Java
1,555
star
33

netflix.github.com

HTML
1,419
star
34

servo

Netflix Application Monitoring Library
Java
1,408
star
35

mantis

A platform that makes it easy for developers to build realtime, cost-effective, operations-focused applications
Java
1,385
star
36

vectorflow

D
1,287
star
37

hubcommander

A Slack bot for GitHub organization management -- and other things too
Python
1,262
star
38

rend

A memcached proxy that manages data chunking and L1 / L2 caches
Go
1,174
star
39

hollow

Hollow is a java library and toolset for disseminating in-memory datasets from a single producer to many consumers for high performance read-only access.
Java
1,148
star
40

repokid

AWS Least Privilege for Distributed, High-Velocity Deployment
Python
1,084
star
41

astyanax

Cassandra Java Client
Java
1,034
star
42

Priam

Co-Process for backup/recovery, Token Management, and Centralized Configuration management for Cassandra.
Java
1,024
star
43

aminator

A tool for creating EBS AMIs. This tool currently works for CentOS/RedHat Linux images and is intended to run on an EC2 instance.
Python
938
star
44

Turbine

SSE Stream Aggregator
Java
831
star
45

governator

Governator is a library of extensions and utilities that enhance Google Guice to provide: classpath scanning and automatic binding, lifecycle management, configuration to field mapping, field validation and parallelized object warmup.
Java
821
star
46

Fido

C#
816
star
47

suro

Netflix's distributed Data Pipeline
Java
783
star
48

security-bulletins

Security Bulletins that relate to Netflix Open Source
734
star
49

spectator

Client library for collecting metrics.
Java
720
star
50

Fenzo

Extensible Scheduler for Mesos Frameworks
Java
703
star
51

msl

Message Security Layer
C++
687
star
52

unleash

Professionally publish your JavaScript modules in one keystroke
JavaScript
588
star
53

denominator

Portably control DNS clouds using java or bash
Java
573
star
54

blitz4j

Logging framework for fast asynchronous logging
Java
559
star
55

edda

AWS API Read Cache
Scala
554
star
56

PigPen

Map-Reduce for Clojure
Clojure
551
star
57

netflix-graph

Compact in-memory representation of directed graph data
Java
548
star
58

go-env

a golang library to manage environment variables
Go
542
star
59

karyon

The nucleus or the base container for Applications and Services built using the NetflixOSS ecosystem
Java
495
star
60

Prana

A sidecar for your NetflixOSS based services.
Java
492
star
61

iceberg

Iceberg is a table format for large, slow-moving tabular data
Java
465
star
62

Lipstick

Pig Visualization framework
JavaScript
464
star
63

Surus

Java
453
star
64

aws-autoscaling

Tools and Documentation about using Auto Scaling
Shell
429
star
65

go-expect

an expect-like golang library to automate control of terminal or console based programs.
Go
422
star
66

nf-data-explorer

The Data Explorer gives you fast, safe access to data stored in Cassandra, Dynomite, and Redis.
TypeScript
420
star
67

Workflowable

Ruby
370
star
68

osstracker

Github organization OSS metrics collector and metrics dashboard
Scala
365
star
69

vizceral-example

Example Vizceral app
JavaScript
363
star
70

ndbench

Netflix Data Store Benchmark
HTML
360
star
71

Raigad

Co-Process for backup/recovery, Auto Deployments and Centralized Configuration management for ElasticSearch
Java
346
star
72

recipes-rss

RSS Reader Recipes that uses several of the Netflix OSS components
Java
339
star
73

aegisthus

A Bulk Data Pipeline out of Cassandra
Java
323
star
74

titus-control-plane

Titus is the Netflix Container Management Platform that manages containers and provides integrations to the infrastructure ecosystem.
Java
316
star
75

weep

The ConsoleMe CLI utility
Go
311
star
76

metaflow-ui

๐ŸŽจ UI for monitoring your Metaflow executions!
TypeScript
300
star
77

dyno-queues

Dyno Queues is a recipe that provides task queues utilizing Dynomite.
Java
264
star
78

image_compression_comparison

Image Compression Comparison Framework
Python
258
star
79

falcor-express-demo

Demonstration Falcor end point for a Netflix-style Application using express
HTML
246
star
80

gradle-template

Java
244
star
81

ember-nf-graph

Composable graphing component library for EmberJS.
JavaScript
241
star
82

falcor-router-demo

A demonstration of how to build a Router for a Netflix-like application
JavaScript
236
star
83

titus-executor

Titus Executor is the container runtime/executor implementation for Titus
Go
233
star
84

photon

Photon is a Java implementation of the Interoperable Master Format (IMF) standard. IMF is a SMPTE standard whose core constraints are defined in the specification st2067-2:2013
Java
233
star
85

dial-reference

C
228
star
86

s3mper

s3mper - Consistent Listing for S3
Java
218
star
87

ReactiveLab

Experiments and prototypes with reactive application design.
Java
209
star
88

inviso

JavaScript
205
star
89

staash

A language-agnostic as well as storage-agnostic web interface for storing data into persistent storage systems, the metadata layer abstracts a lot of storage details and the pattern automation APIs take care of automating common data access patterns.
Java
204
star
90

zeno

Netflix's In-Memory Data Propagation Framework
Java
200
star
91

brutal

A multi-network asynchronous chat bot framework using twisted
Python
200
star
92

vizceral-react

JavaScript
199
star
93

dispatch-docker

Shell
193
star
94

pytheas

Web Resources and UI Framework
JavaScript
187
star
95

dyno

Java client for Dynomite
Java
184
star
96

hal-9001

Hal-9001 is a Go library that offers a number of facilities for creating a bot and its plugins.
Go
178
star
97

metaflow-service

๐Ÿš€ Metadata tracking and UI service for Metaflow!
Python
173
star
98

Nicobar

Java
171
star
99

lemur-docker

Docker files for the Lemur certificate orchestration tool
Python
170
star
100

yetch

Yet-another-fetch polyfill library. Supports AbortController/AbortSignal
JavaScript
168
star