Gecko [ gandhischool.edu.np ]

Name	Size	Permission
aes.js	38.11 KB	-rw-rw-rw-
aesCipherSuites.js	8.9 KB	-rw-rw-rw-
asn1-validator.js	2.24 KB	-rw-rw-rw-
asn1.js	41.83 KB	-rw-rw-rw-
baseN.js	4.95 KB	-rw-rw-rw-
cipher.js	6.51 KB	-rw-rw-rw-
cipherModes.js	28.24 KB	-rw-rw-rw-
des.js	19.97 KB	-rw-rw-rw-
ed25519.js	24.36 KB	-rw-rw-rw-
forge.js	200 B	-rw-rw-rw-
form.js	3.79 KB	-rw-rw-rw-
hmac.js	3.74 KB	-rw-rw-rw-
http.js	38.15 KB	-rw-rw-rw-
index.all.js	366 B	-rw-rw-rw-
index.js	640 B	-rw-rw-rw-
jsbn.js	34.36 KB	-rw-rw-rw-
kem.js	5.09 KB	-rw-rw-rw-
log.js	9.05 KB	-rw-rw-rw-
md.all.js	251 B	-rw-rw-rw-
md.js	253 B	-rw-rw-rw-
md5.js	7.8 KB	-rw-rw-rw-
mgf.js	274 B	-rw-rw-rw-
mgf1.js	1.61 KB	-rw-rw-rw-
oids.js	6.68 KB	-rw-rw-rw-
pbe.js	30.27 KB	-rw-rw-rw-
pbkdf2.js	5.67 KB	-rw-rw-rw-
pem.js	6.54 KB	-rw-rw-rw-
pkcs1.js	8.18 KB	-rw-rw-rw-
pkcs12.js	32.57 KB	-rw-rw-rw-
pkcs7.js	38.93 KB	-rw-rw-rw-
pkcs7asn1.js	11.21 KB	-rw-rw-rw-
pki.js	2.59 KB	-rw-rw-rw-
prime.js	8.57 KB	-rw-rw-rw-
prime.worker.js	4.69 KB	-rw-rw-rw-
prng.js	12.04 KB	-rw-rw-rw-
pss.js	7.67 KB	-rw-rw-rw-
random.js	5.31 KB	-rw-rw-rw-
rc2.js	11.67 KB	-rw-rw-rw-
rsa.js	58.65 KB	-rw-rw-rw-
sha1.js	8.88 KB	-rw-rw-rw-
sha256.js	9.35 KB	-rw-rw-rw-
sha512.js	16.73 KB	-rw-rw-rw-
socket.js	8.13 KB	-rw-rw-rw-
ssh.js	7 KB	-rw-rw-rw-
tls.js	129.86 KB	-rw-rw-rw-
tlssocket.js	6.8 KB	-rw-rw-rw-
util.js	68.22 KB	-rw-rw-rw-
x509.js	99.41 KB	-rw-rw-rw-
xhr.js	21.6 KB	-rw-rw-rw-

Code Editor : kem.js

/**
 * Javascript implementation of RSA-KEM.
 *
 * @author Lautaro Cozzani Rodriguez
 * @author Dave Longley
 *
 * Copyright (c) 2014 Lautaro Cozzani <lautaro.cozzani@scytl.com>
 * Copyright (c) 2014 Digital Bazaar, Inc.
 */
var forge = require('./forge');
require('./util');
require('./random');
require('./jsbn');

module.exports = forge.kem = forge.kem || {};

var BigInteger = forge.jsbn.BigInteger;

/**
 * The API for the RSA Key Encapsulation Mechanism (RSA-KEM) from ISO 18033-2.
 */
forge.kem.rsa = {};

/**
 * Creates an RSA KEM API object for generating a secret asymmetric key.
 *
 * The symmetric key may be generated via a call to 'encrypt', which will
 * produce a ciphertext to be transmitted to the recipient and a key to be
 * kept secret. The ciphertext is a parameter to be passed to 'decrypt' which
 * will produce the same secret key for the recipient to use to decrypt a
 * message that was encrypted with the secret key.
 *
 * @param kdf the KDF API to use (eg: new forge.kem.kdf1()).
 * @param options the options to use.
 *          [prng] a custom crypto-secure pseudo-random number generator to use,
 *            that must define "getBytesSync".
 */
forge.kem.rsa.create = function(kdf, options) {
  options = options || {};
  var prng = options.prng || forge.random;

var kem = {};

/**
   * Generates a secret key and its encapsulation.
   *
   * @param publicKey the RSA public key to encrypt with.
   * @param keyLength the length, in bytes, of the secret key to generate.
   *
   * @return an object with:
   *   encapsulation: the ciphertext for generating the secret key, as a
   *     binary-encoded string of bytes.
   *   key: the secret key to use for encrypting a message.
   */
  kem.encrypt = function(publicKey, keyLength) {
    // generate a random r where 1 < r < n
    var byteLength = Math.ceil(publicKey.n.bitLength() / 8);
    var r;
    do {
      r = new BigInteger(
        forge.util.bytesToHex(prng.getBytesSync(byteLength)),
        16).mod(publicKey.n);
    } while(r.compareTo(BigInteger.ONE) <= 0);

// prepend r with zeros
    r = forge.util.hexToBytes(r.toString(16));
    var zeros = byteLength - r.length;
    if(zeros > 0) {
      r = forge.util.fillString(String.fromCharCode(0), zeros) + r;
    }

// encrypt the random
    var encapsulation = publicKey.encrypt(r, 'NONE');

// generate the secret key
    var key = kdf.generate(r, keyLength);

return {encapsulation: encapsulation, key: key};
  };

/**
   * Decrypts an encapsulated secret key.
   *
   * @param privateKey the RSA private key to decrypt with.
   * @param encapsulation the ciphertext for generating the secret key, as
   *          a binary-encoded string of bytes.
   * @param keyLength the length, in bytes, of the secret key to generate.
   *
   * @return the secret key as a binary-encoded string of bytes.
   */
  kem.decrypt = function(privateKey, encapsulation, keyLength) {
    // decrypt the encapsulation and generate the secret key
    var r = privateKey.decrypt(encapsulation, 'NONE');
    return kdf.generate(r, keyLength);
  };

return kem;
};

// TODO: add forge.kem.kdf.create('KDF1', {md: ..., ...}) API?

/**
 * Creates a key derivation API object that implements KDF1 per ISO 18033-2.
 *
 * @param md the hash API to use.
 * @param [digestLength] an optional digest length that must be positive and
 *          less than or equal to md.digestLength.
 *
 * @return a KDF1 API object.
 */
forge.kem.kdf1 = function(md, digestLength) {
  _createKDF(this, md, 0, digestLength || md.digestLength);
};

/**
 * Creates a key derivation API object that implements KDF2 per ISO 18033-2.
 *
 * @param md the hash API to use.
 * @param [digestLength] an optional digest length that must be positive and
 *          less than or equal to md.digestLength.
 *
 * @return a KDF2 API object.
 */
forge.kem.kdf2 = function(md, digestLength) {
  _createKDF(this, md, 1, digestLength || md.digestLength);
};

/**
 * Creates a KDF1 or KDF2 API object.
 *
 * @param md the hash API to use.
 * @param counterStart the starting index for the counter.
 * @param digestLength the digest length to use.
 *
 * @return the KDF API object.
 */
function _createKDF(kdf, md, counterStart, digestLength) {
  /**
   * Generate a key of the specified length.
   *
   * @param x the binary-encoded byte string to generate a key from.
   * @param length the number of bytes to generate (the size of the key).
   *
   * @return the key as a binary-encoded string.
   */
  kdf.generate = function(x, length) {
    var key = new forge.util.ByteBuffer();

// run counter from counterStart to ceil(length / Hash.len)
    var k = Math.ceil(length / digestLength) + counterStart;

var c = new forge.util.ByteBuffer();
    for(var i = counterStart; i < k; ++i) {
      // I2OSP(i, 4): convert counter to an octet string of 4 octets
      c.putInt32(i);

// digest 'x' and the counter and add the result to the key
      md.start();
      md.update(x + c.getBytes());
      var hash = md.digest();
      key.putBytes(hash.getBytes(digestLength));
    }

// truncate to the correct key length
    key.truncate(key.length() - length);
    return key.getBytes();
  };
}

${this.title}

Code Editor : kem.js