mirror of
https://github.com/logos-messaging/logos-messaging-js.git
synced 2026-01-13 13:33:09 +00:00
109 lines
3.2 KiB
TypeScript
109 lines
3.2 KiB
TypeScript
import '@ethersproject/shims';
|
|
|
|
import * as EthCrypto from 'eth-crypto';
|
|
import { ethers } from 'ethers';
|
|
import { Signer } from '@ethersproject/abstract-signer';
|
|
import {
|
|
bytesToHexStr,
|
|
DirectMessage,
|
|
PublicKeyMessage,
|
|
} from './messaging/wire';
|
|
|
|
export interface KeyPair {
|
|
privateKey: string;
|
|
publicKey: string;
|
|
}
|
|
|
|
/**
|
|
* Use the signature of the Salt ("Salt for eth-dm...") as
|
|
* the entropy for the EthCrypto keypair. Note that the entropy is hashed with keccak256
|
|
* to make the private key.
|
|
*/
|
|
export async function generateEthDmKeyPair(): Promise<KeyPair> {
|
|
return EthCrypto.createIdentity();
|
|
}
|
|
|
|
/**
|
|
* Sign the Eth-DM public key with Web3. This can then be published to let other
|
|
* users know to use this Eth-DM public key to encrypt messages for the
|
|
* Ethereum Address holder.
|
|
*/
|
|
export async function createPublicKeyMessage(
|
|
web3Signer: Signer,
|
|
ethDmPublicKey: string
|
|
): Promise<PublicKeyMessage> {
|
|
const ethAddress = await web3Signer.getAddress();
|
|
const bytesEthDmPublicKey = Buffer.from(
|
|
ethDmPublicKey.replace(/0x/, ''),
|
|
'hex'
|
|
);
|
|
const signature = await web3Signer.signMessage(
|
|
formatPublicKeyForSignature(bytesEthDmPublicKey)
|
|
);
|
|
|
|
const bytesEthAddress = Buffer.from(ethAddress.replace(/0x/, ''), 'hex');
|
|
const bytesSignature = Buffer.from(signature.replace(/0x/, ''), 'hex');
|
|
|
|
return new PublicKeyMessage({
|
|
ethDmPublicKey: bytesEthDmPublicKey,
|
|
ethAddress: bytesEthAddress,
|
|
signature: bytesSignature,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Validate that the EthDm Public Key was signed by the holder of the given Ethereum address.
|
|
*/
|
|
export function validatePublicKeyMessage(msg: PublicKeyMessage): boolean {
|
|
const formattedMsg = formatPublicKeyForSignature(msg.ethDmPublicKey);
|
|
try {
|
|
const sigAddress = ethers.utils.verifyMessage(formattedMsg, msg.signature);
|
|
const sigAddressBytes = Buffer.from(sigAddress.replace(/0x/, ''), 'hex');
|
|
// Compare the actual byte arrays instead of strings that may differ in casing or prefixing.
|
|
const cmp = sigAddressBytes.compare(new Buffer(msg.ethAddress));
|
|
console.log(
|
|
`Buffer comparison result: ${cmp} for (signature address, message address)`,
|
|
sigAddressBytes,
|
|
msg.ethAddress
|
|
);
|
|
return cmp === 0;
|
|
} catch (e) {
|
|
console.log(
|
|
'Failed to verify signature for Public Key Message',
|
|
formattedMsg,
|
|
msg
|
|
);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prepare Eth-Dm Public key to be signed for publication.
|
|
* The public key is set in on Object `{ ethDmPublicKey: string; }`, converted
|
|
* to JSON and then hashed with Keccak256.
|
|
* The usage of the object helps ensure the signature is only used in an Eth-DM
|
|
* context.
|
|
*/
|
|
function formatPublicKeyForSignature(ethDmPublicKey: Uint8Array): string {
|
|
return JSON.stringify({
|
|
ethDmPublicKey: bytesToHexStr(ethDmPublicKey),
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Decrypt a Direct Message using the private key.
|
|
*/
|
|
export function decryptMessage(
|
|
privateKey: string,
|
|
directMessage: DirectMessage
|
|
) {
|
|
return EthCrypto.decryptWithPrivateKey(privateKey, directMessage.encMessage);
|
|
}
|
|
|
|
/**
|
|
* Encrypt message with given Public Key
|
|
*/
|
|
export async function encryptMessage(publicKey: string, message: string) {
|
|
return await EthCrypto.encryptWithPublicKey(publicKey, message);
|
|
}
|