cleansend
Version:
A TypeScript implementation of the OpenMsg Protocol - secure, decentralized messaging system with end-to-end encryption for cross-domain communication
132 lines • 4.18 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateRandomBytes = generateRandomBytes;
exports.generateRandomHex = generateRandomHex;
exports.generateAuthCode = generateAuthCode;
exports.generateIdentCode = generateIdentCode;
exports.generateMessageCryptKey = generateMessageCryptKey;
exports.generateMessageSalt = generateMessageSalt;
exports.encryptMessage = encryptMessage;
exports.decryptMessage = decryptMessage;
exports.createMessagePackage = createMessagePackage;
exports.decryptMessagePackage = decryptMessagePackage;
exports.createHash = createHash;
exports.createMessageHash = createMessageHash;
const crypto_1 = __importDefault(require("crypto"));
/**
* Generate random bytes
*/
function generateRandomBytes(length) {
return crypto_1.default.randomBytes(length);
}
/**
* Generate random hex string
*/
function generateRandomHex(length) {
return crypto_1.default.randomBytes(length).toString('hex');
}
/**
* Generate auth code (64 chars hex)
*/
function generateAuthCode() {
return generateRandomHex(32);
}
/**
* Generate ident code (64 chars hex)
*/
function generateIdentCode() {
return generateRandomHex(32);
}
/**
* Generate message crypt key (64 chars hex)
*/
function generateMessageCryptKey() {
return generateRandomHex(32);
}
/**
* Generate message salt (32 chars hex)
*/
function generateMessageSalt() {
return generateRandomHex(16);
}
/**
* Encrypt message using AES-256-GCM
*/
function encryptMessage(plaintext, key, nonce) {
const cipher = crypto_1.default.createCipher('aes-256-gcm', Buffer.from(key, 'hex'));
cipher.setAAD(nonce);
let encrypted = cipher.update(plaintext, 'utf8', 'base64');
encrypted += cipher.final('base64');
const authTag = cipher.getAuthTag();
return {
encrypted,
authTag: authTag.toString('base64'),
nonce: nonce.toString('base64')
};
}
/**
* Decrypt message using AES-256-GCM
*/
function decryptMessage(encryptedData, key, nonce, authTag) {
try {
const decipher = crypto_1.default.createDecipher('aes-256-gcm', Buffer.from(key, 'hex'));
decipher.setAAD(Buffer.from(nonce, 'base64'));
decipher.setAuthTag(Buffer.from(authTag, 'base64'));
let decrypted = decipher.update(encryptedData, 'base64', 'utf8');
decrypted += decipher.final('utf8');
return decrypted;
}
catch (error) {
return false;
}
}
/**
* Create message package (nonce + encrypted message)
*/
function createMessagePackage(plaintext, key) {
const nonce = generateRandomBytes(16);
const cipher = crypto_1.default.createCipher('aes-256-gcm', Buffer.from(key, 'hex'));
let encrypted = cipher.update(plaintext, 'utf8');
encrypted = Buffer.concat([encrypted, cipher.final()]);
const authTag = cipher.getAuthTag();
const packageBuffer = Buffer.concat([nonce, encrypted, authTag]);
return {
package: packageBuffer.toString('base64'),
nonce: nonce.toString('base64')
};
}
/**
* Decrypt message package
*/
function decryptMessagePackage(packageBase64, key) {
try {
const packageBuffer = Buffer.from(packageBase64, 'base64');
const authTag = packageBuffer.slice(-16);
const encrypted = packageBuffer.slice(16, -16);
const decipher = crypto_1.default.createDecipher('aes-256-gcm', Buffer.from(key, 'hex'));
decipher.setAuthTag(authTag);
let decrypted = decipher.update(encrypted, undefined, 'utf8');
decrypted += decipher.final('utf8');
return decrypted;
}
catch (error) {
return false;
}
}
/**
* Create SHA256 hash
*/
function createHash(data) {
return crypto_1.default.createHash('sha256').update(data).digest('hex');
}
/**
* Create message hash
*/
function createMessageHash(messagePackage, authCode, messageSalt, messageTimestamp) {
const data = messagePackage + authCode + messageSalt + messageTimestamp.toString();
return createHash(data);
}
//# sourceMappingURL=crypto.js.map