# Tutorial: Encrypt and sign a message
With ethereum-keys you cannot only interact with the blockchain, but also use them to send messages over mutual untrusted channels in a secure way. In this tutorial we will use ethereum-identities to send messages like you would do in a decentralized chat-app.
## Prerequisites
First we create two identities, `Alice` and `Bob` . In our case `Alice` wants to send the message `My name is Satoshi Buterin` to `Bob` .
```javascript
const EthCrypto = require('eth-crypto');
const alice = EthCrypto.createIdentity();
const bob = EthCrypto.createIdentity();
const secretMessage = 'My name is Satoshi Buterin';
```
## Encrypt and sign the message
Before we send the message from `Alice` to `Bob` , we want to ensure that
- Only `Bob` can read the message
- `Bob` can be sure that the message really comes from `Alice`
To do this, we first sign the message with alice's privateKey and then encrypt the message and the signature with bob's publicKey.
```javascript
const signature = EthCrypto.sign(
alice.privateKey,
EthCrypto.hash.keccak256(secretMessage)
);
const payload = {
message: secretMessage,
signature
};
const encrypted = await EthCrypto.encryptWithPublicKey(
bob.publicKey, // by encrypting with bobs publicKey, only bob can decrypt the payload with his privateKey
JSON.stringify(payload) // we have to stringify the payload before we can encrypt it
);
/* { iv: 'c66fbc24cc7ef520a7...',
ephemPublicKey: '048e34ce5cca0b69d4e1f5...',
ciphertext: '27b91fe986e3ab030...',
mac: 'dd7b78c16e462c42876745c7...'
}
*/
// we convert the object into a smaller string-representation
const encryptedString = EthCrypto.cipher.stringify(encrypted);
// > '812ee676cf06ba72316862fd3dabe7e403c7395bda62243b7b0eea5eb..'
// now we send the encrypted string to bob over the internet.. *bieb, bieb, blob*
```
## Decrypt and verify the payload
When bob receives the message, he starts with decrypting it with his privateKey and then verifies the signature.
```javascript
// we parse the string into the object again
const encryptedObject = EthCrypto.cipher.parse(encryptedString);
const decrypted = await EthCrypto.decryptWithPrivateKey(
bob.privateKey,
encryptedObject
);
const decryptedPayload = JSON.parse(decrypted);
// check signature
const senderAddress = EthCrypto.recover(
decryptedPayload.signature,
EthCrypto.hash.keccak256(decryptedPayload.message)
);
console.log(
'Got message from ' +
senderAddress +
': ' +
decryptedPayload.message
);
// > 'Got message from 0x19C24B2d99FB91C5...: "My name is Satoshi Buterin" Buterin'
```
## Creating an answer
Now that `Bob` got the message, he can also answer back to alice.
To do this he has to recover the publicKey of alice with `recoverPublicKey()` .
```javascript
const answerMessage = 'And I am Bob Kelso';
const answerSignature = EthCrypto.sign(
bob.privateKey,
EthCrypto.hash.keccak256(answerMessage)
);
const answerPayload = {
message: answerMessage,
signature: answerSignature
};
const alicePublicKey = EthCrypto.recoverPublicKey(
decryptedPayload.signature,
EthCrypto.hash.keccak256(payload.message)
);
const encryptedAnswer = await EthCrypto.encryptWithPublicKey(
alicePublicKey,
JSON.stringify(answerPayload)
);
// now we send the encryptedAnswer to alice over the internet.. *bieb, bieb, blob*
```
