// 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);
}

<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>

<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>

<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>

<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>