keyPairSchema.statics.updateMasterKeyPairForUser = function updateMasterKeyPairForUser(user, masterKeyPair, keyId, callback) {
//console.log("Updating master keyPair for "+user.userName);
//console.log("[DEBUG] (updateMasterKeyPairForUser) user.publicKey: "+user.publicKey);
//console.log("[DEBUG] (updateMasterKeyPairForUser) masterKeyPair.privateKey: "+masterKeyPair.privateKey);
if (user.publicKey) {
var publicKey = openpgp.key.readArmored(user.publicKey).keys[0];
var masterPrivateKey = openpgp.key.readArmored(masterKeyPair.privateKey).keys[0];
masterPrivateKey.decrypt('pipo');
//console.log("Encrypting master key with id "+keyId+" to "+user.userName);
openpgp.encryptMessage(publicKey, masterKeyPair.privateKey).then(function(encKey) {
User.findOne({ userName: user.userName }, function(err, user, count) {
user.masterKeyPair.encryptedPrivateKey = encKey;
user.masterKeyPair.publicKey = masterKeyPair.publicKey;
user.masterKeyPair.id = keyId;
user.save( function( err, user ) {
//if (err) { return callback("Error saving encrypted master key for user "+user.userName) };
//console.log("Saved encrypted master key for user "+user.userName);
//console.log("[DEBUG] (updateMaseterKeyPairForUser) user.masterKey.encryptedMasterKey: "+user.masterKey.encryptedMasterKey);
callback(null);
});
});
});
} else {
console.log("User "+user.userName+" does not have a publicKey so cannot create master key for them");
callback(null);
}
}
function(err, publicKey) {
if(err) {
send(client, "ERROR " + err);
console.error("Error requesting public key: " + err);
return;
}
// Generate new challenge
var hostCode = generateUID('xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx');
if(typeof keyspaceChallenges[hostCode] !== 'undefined')
throw new Error("Host Code already exists: " + hostCode);
keyspaceChallenges[hostCode] = [pgp_id_public, client, callback];
if(typeof openpgp === 'undefined')
var openpgp = require('openpgp');
openpgp.encryptMessage(publicKey, hostCode)
.then(function(encryptedMessage) {
console.info("Sending KeySpace Auth Challenge...");
send(client, "KEYSPACE.AUTH.CHALLENGE " + encryptedMessage);
//ServerSubscriptions.notifyAllAuthenticatedKeySpaceClients(pgp_id_public, "EVENT KEYSPACE.HOST.CHALLENGE " + encryptedMessage);
}).catch(function(error) {
send(client, "ERROR " + error);
console.error("Error encrypting KeySpace Auth Challenge: " + err);
});
}
it('should work without signature', function(done) {
var ct = openpgp.encryptMessage([pgp._publicKey], message);
pgp.decrypt(ct, undefined, function(err, pt, signValid) {
expect(err).to.not.exist;
expect(pt).to.equal(message);
expect(signValid).to.be.undefined;
done();
});
});
context.lookup(PGP_NAME, PGP_TYPE, function(err, result) {
if(err){ return callback(err, null); }
var record = getFirstSecureResponse(result, PGP_TYPE);
if (typeof record === "string") {
// error
return callback(record, null);
}
var key = record.rdata.rdata_raw;
var publicKey = openpgp.key.readArmored(key);
var pgpMessage = openpgp.encryptMessage(publicKey.keys, MESSAGE);
return callback(null, pgpMessage);
});
Identity.prototype.encrypt = function(keys, message, callback) {
try {
assert(Array.isArray(keys), 'Keys must be an array');
assert(typeof message === 'string', 'Message must be a string');
} catch(err) {
return callback(err);
}
keys.push(this.privateKey); // include our own key
pgp.encryptMessage(keys, message).then(function(result) {
callback(null, result);
}).catch(callback);
};
function doEncrypt(plaintext) {
openpgp.encryptMessage(pubKey, plaintext).then(function(pgpMessage) {
pgpMessage = pgpMessage.replace('OpenPGP.js', 'Profanity-PGP');
pgpMessage = pgpMessage.replace('http://openpgpjs.org', 'https://github.com/mapmeld/profanity-pgp');
var msg = pgpMessage.split('\n');
for(var l = 4; l < msg.length - 2; l++) {
var original_line = msg[l];
var new_line = [];
for(var sym = 0; sym < original_line.length; sym++) {
var symbol_index = originalSymbols.indexOf(original_line[sym]);
new_line.push(profanity[symbol_index]);
}
msg[l] = new_line.join(' ');
}
console.log(msg.join('\n'));
}).catch(function(err) {
throw err;
});
}
return Promise.all(_.map(payloadData, function(data) {
// Create message to encrypt
var message = {
messageVersion: data.messageVersion || defaultMessageVersion,
taskId: data.taskId,
startTime: data.startTime || Date.now(),
endTime: data.endTime || (Date.now() + 30000),
name: data.name,
value: data.value
};
message = JSON.stringify(message);
var encryptMessage = openpgp.encryptMessage(pubKey.keys, message);
return encryptMessage.then(function(encryptedMsg) {
var unarmoredEncryptedData = openpgp.armor.decode(encryptedMsg).data;
var result = new Buffer(unarmoredEncryptedData, 'binary').toString('base64');
return result;
}).catch(function(error) {
throw('Unable to encrypt data: ' + error);
});
}));
function encryptMessage(message, keyIdsHex, callback) {
var keys = keyIdsHex.map(function(keyIdHex) {
var keyArray = keyring.getKeysForId(keyIdHex);
return keyArray ? keyArray[0] : null;
}).filter(function(key) {
return key !== null;
});
if (keys.length === 0) {
callback({
type: 'error',
message: 'No key found for encryption'
});
}
try {
var encrypted = openpgp.encryptMessage(keys, message);
callback(null, encrypted);
} catch (e) {
callback({
type: 'error',
message: l10n('encrypt_error', [e])
});
}
}
function sign(key) {
var publicKey = openpgp.key.readArmored(key)
var pgpMessage = openpgp.encryptMessage(publicKey.keys, 'Hello, World!')
console.log([key, publicKey, pgpMessage])
}