Please note that as of October 24, 2014, the Nokia Developer Wiki will no longer be accepting user contributions, including new entries, edits and comments, as we begin transitioning to our new home, in the Windows Phone Development Wiki. We plan to move over the majority of the existing entries over the next few weeks. Thanks for all your past and future contributions.

# Diffie Hellman key exchange

## Contents |

## Over View

The following code snippet demonstrates the **Diffie-Hellman** key exchange algorithm which is a cryptography algorithm that allows two parties to jointly establish a shared secret key over an insecure communication channel. Diffie Hellman method is used to jointly arrive at the same Shared key and you can read more here.

## Header Required

`#include <cryptoasymmetric.h>`

## Library Required

`LIBRARY cryptography.lib`

Following are the steps involved in this algorithm:

**1)** Create two objects of **RInteger** class(a **TInteger** derived class allowing the construction of variable length big integers) each for a prime Number 'P'& a generator':

RInteger PrimeNum = RInteger::NewPrimeL(1024)//pass here the number of bits of prime number you wish to generate e.g. passing 1024 will generate a 1024 bit prime number.

RInteger Generator=RInteger::NewL(5); // generator is generated by passing a constant which is usually 2 or 5

**2)** Create an object of **CDHKeyPair** class using the RInteger objects created in **Step 1** :

TRAPD(err,iDHKeyPair = CDHKeyPair::NewL(PrimeNum ,Generator));

**3)** Next get the 'G'(generator) & 'N'(Prime Number) parameters of Diffie Hellman using the CDHkeyPair object created in Step 2 :

const TInteger& G =iDHKeyPair->PublicKey().G();

const TInteger& N =iDHKeyPair->PublicKey().N();

//Get the Prime Number in a buffer as below :

HBufC8 *PrimeBuffer=N.BufferLC();

TPtr8 PtrPrime=PrimeBuffer->Des();

//Also get the DH value 'x'(a random large integer) as:

const TInteger& xparam =iDHKeyPair->PrivateKey().x();

**4)** Next generate the DH public value/parameter(PublicVal) which is to be exchanged with the party other side as below:

const TInteger& PublicVal = (G.TimesL(xparam )).ModuloL(N);

HBufC8 *Buffervalue = PublicVal .BufferLC();

TPtr8 NewPublicVal = Buffervalue ->Des();

**5)** Now send the Prime Number which is generated in **Step 3** to the other party by the way you wish to send.

**6)** The receiving party(which will receive the Prime Number) will now repeat the Steps 1 to 4, with **Step 1** as below:

RInteger PrimeNumReceiver = RInteger::NewL(const TDesC8&//Prime Number Received from Sender side)

RInteger GeneratorReceiver=RInteger::NewL(5);

//Rest of the steps will be same on receiver side but will require the use of

//received prime number where it is required.

**7)** Now there will be two public values/parameters generated, one at the Sender's end & one at receiver's end, both generated using the same prime Number.So now **exchange** the two public values/parameters i.e. the sender will send its value to receiver & vice-versa.

**8)** Now with public values got exchanged the two parties will now generate a common/shared secret at their ends:

RInteger PrivateValue = RInteger::NewL(const TDesC8& privateParam//private parameter 'x' generated at each side in Step 3);

RInteger PrimeNum = RInteger::NewL(const TDesC8& Prime//the common Prime Number);

RInteger ReceivedPublic = RInteger::NewL(const TDesC8& publicParam //the exchanged public value);

//The common/Shared secret key will be generated at each end as below:

const TInteger& SharedKey = (ReceivedPublic.TimesL(Private)).ModuloL(PrimeNum );

- The above generated shared secret key will be same as generated at both the ends(sender & receiver) & now they can use it as they want like using it as an encryption/decryption key in any of the
**Symmetrical**Cryptographic algorithms.

I think that in the Diffie Hellman key exchange it is more proper to use the ModularExponentiateL() function or in general the ExponentiateL() function rather then TimesL().