No OneTemporary
Actions

Size

71 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/deps/pjsip/third_party/zsrtp/include/ZsrtpCWrapper.h b/deps/pjsip/third_party/zsrtp/include/ZsrtpCWrapper.h
	index c49a9d10..40613be0 100644
	--- a/deps/pjsip/third_party/zsrtp/include/ZsrtpCWrapper.h
	+++ b/deps/pjsip/third_party/zsrtp/include/ZsrtpCWrapper.h
	@@ -1,448 +1,455 @@
	/*
	This file defines the ZRTP SRTP C-to-C++ wrapper.
	Copyright (C) 2010 Werner Dittmann

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program. If not, see <http://www.gnu.org/licenses/>.

	*/

	#ifndef ZSRTPCWRAPPER_H
	#define ZSRTPCWRAPPER_H

	/**
	* @file ZsrtpCWrapper.h
	* @brief C-to-C++ wrapper for the C++ based SRTP and SRTCP implementation
	* @defgroup Z_SRTP SRTP/SRTCP implementation for ZRTP including C-to-C++ wrapper
	* @ingroup PJMEDIA_TRANSPORT_ZRTP
	* @{
	*/

	#include <stdint.h>

	/*
	* Keep in synch with CryptoContext.h
	*/
	#define SrtpAuthenticationNull 0
	#define SrtpAuthenticationSha1Hmac 1
	#define SrtpAuthenticationSkeinHmac 2


	#define SrtpEncryptionNull 0
	#define SrtpEncryptionAESCM 1
	#define SrtpEncryptionAESF8 2
	#define SrtpEncryptionTWOCM 3
	#define SrtpEncryptionTWOF8 4


	#ifdef __cplusplus
	extern "C"
	{
	#endif
	+#ifdef __cplusplus
	+ typedef class CryptoContext CryptoContext;
	+#else
	typedef struct CryptoContext CryptoContext;
	+#endif

	typedef struct zsrtpContext
	{
	CryptoContext* srtp;
	void* userData;
	} ZsrtpContext;

	/**
	* Create a ZSRTP wrapper fir a SRTP cryptographic context.
	*
	* This constructor creates an active SRTP cryptographic context were
	* algorithms are enabled, keys are computed and so on. This SRTP
	* cryptographic context can protect a RTP SSRC stream.
	*
	* @param ssrc
	* The RTP SSRC that this SRTP cryptographic context protects.
	*
	* @param roc
	* The initial Roll-Over-Counter according to RFC 3711. These are the
	* upper 32 bit of the overall 48 bit SRTP packet index. Refer to
	* chapter 3.2.1 of the RFC.
	*
	* @param keyDerivRate
	* The key derivation rate defines when to recompute the SRTP session
	* keys. Refer to chapter 4.3.1 in the RFC.
	*
	* @param ealg
	* The encryption algorithm to use. Possible values are <code>
	* SrtpEncryptionNull, SrtpEncryptionAESCM, SrtpEncryptionAESF8
	* </code>. See chapter 4.1.1 for AESCM (Counter mode) and 4.1.2
	* for AES F8 mode.
	*
	* @param aalg
	* The authentication algorithm to use. Possible values are <code>
	* SrtpEncryptionNull, SrtpAuthenticationSha1Hmac</code>. The only
	* active algorithm here is SHA1 HMAC, a SHA1 based hashed message
	* authentication code as defined in RFC 2104.
	*
	* @param masterKey
	* Pointer to the master key for this SRTP cryptographic context.
	* Must point to <code>masterKeyLength</code> bytes. Refer to chapter
	* 3.2.1 of the RFC about the role of the master key.
	*
	* @param masterKeyLength
	* The length in bytes of the master key in bytes. The length must
	* match the selected encryption algorithm. Because SRTP uses AES
	* based encryption only, then master key length may be 16 or 32
	* bytes (128 or 256 bit master key)
	*
	* @param masterSalt
	* SRTP uses the master salt to computer the initialization vector
	* that in turn is input to compute the session key, session
	* authentication key and the session salt.
	*
	* @param masterSaltLength
	* The length in bytes of the master salt data in bytes. SRTP uses
	* AES as encryption algorithm. AES encrypts 16 byte blocks
	* (independent of the key length). According to RFC3711 the standard
	* value for the master salt length should be 112 bit (14 bytes).
	*
	* @param ekeyl
	* The length in bytes of the session encryption key that SRTP shall
	* compute and use. Usually the same length as for the master key
	* length. But you may use a different length as well. Be carefull
	* that the key management mechanisms supports different key lengths.
	*
	* @param akeyl
	* The length in bytes of the session authentication key. SRTP
	* computes this key and uses it as input to the authentication
	* algorithm.
	* The standard value is 160 bits (20 bytes).
	*
	* @param skeyl
	* The length in bytes of the session salt. SRTP computes this salt
	* key and uses it as input during encryption. The length usually
	* is the same as the master salt length.
	*
	* @param tagLength
	* The length is bytes of the authentication tag that SRTP appends
	* to the RTP packet. Refer to chapter 4.2. in the RFC 3711.
	*
	* @returns
	* Pointer to a new ZSRTP wrapper context.
	*/
	ZsrtpContext* zsrtp_CreateWrapper(uint32_t ssrc, int32_t roc,
	int64_t keyDerivRate,
	const int32_t ealg,
	const int32_t aalg,
	uint8_t* masterKey,
	int32_t masterKeyLength,
	uint8_t* masterSalt,
	int32_t masterSaltLength,
	int32_t ekeyl,
	int32_t akeyl,
	int32_t skeyl,
	int32_t tagLength);

	/**
	* Destroy a ZSRTP wrapper Context
	*
	* @param ctx
	* A ZSRTP wrapper context.
	*/
	void zsrtp_DestroyWrapper (ZsrtpContext* ctx);

	/**
	* Encrypt the RTP payload and compute authentication code.
	*
	* The method requires a ready made RTP packet in the RTP packet data
	* buffer.
	*
	* The method computes an authentication code and appends this code to the
	* buffer and computes a new length. The RTP packet buffer must be large
	* enough to hold this authentication code.
	*
	* @param ctx
	* The ZsrtpContext
	*
	* @param buffer
	* Pointer to the data that contains the RTP packet data. SRTP appends
	* the authentication code to the encrypted RTP packet data.
	*
	* @param length
	* Length of the RTP data buffer.
	*
	* @param newLength
	* The new length of the RTP data buffer including authentication code
	*
	* @returns
	* 0 if no active SRTP crypto context, 1 if data is encrypted.
	*/
	int32_t zsrtp_protect(ZsrtpContext* ctx, uint8_t* buffer, int32_t length,
	int32_t* newLength);

	/**
	* Decrypt the RTP payload and check authentication code.
	*
	* The method requires a SRTP packet in the SRTP packet data
	* buffer.
	*
	* SRTP checks SRTP packet replay, then it computes the authentication
	* code and checks if the authentication code is correct. If the checks
	* are ok then SRTP decrypts the payload data.
	*
	* @param ctx
	* The ZsrtpContext
	*
	* @param buffer
	* Pointer to the data that contains the SRTP packet data. SRTP removes
	* the authentication code from the decrypted RTP packet data.
	*
	* @param length
	* Length of the RTP data buffer.
	*
	* @param newLength
	* The new length of the RTP data buffer excluding authentication code
	*
	* @returns
	* 0 if no active SRTP crypto context, 1 if data is decrypted,
	* -1 if data authentication failed, -2 if SRTP replay check failed
	*/
	int32_t zsrtp_unprotect(ZsrtpContext* ctx, uint8_t* buffer, int32_t length,
	int32_t* newLength);

	/**
	* Derive a new Crypto Context for use with a new SSRC
	*
	* This method stores a new Crypto Context initialized with the data
	* of this crypto context. Replacing the SSRC, Roll-over-Counter, and
	* the key derivation rate the application cab use this Crypto Context
	* to encrypt / decrypt a new stream (Synchronization source) inside
	* one RTP session.
	*
	* Before the application can use this crypto context it must call
	* the <code>deriveSrtpKeys</code> method.
	*
	* @param ctx
	* The ZsrtpContext
	* @param ssrc
	* The SSRC for this context
	* @param roc
	* The Roll-Over-Counter for this context
	* @param keyDerivRate
	* The key derivation rate for this context
	*/
	void zsrtp_newCryptoContextForSSRC(ZsrtpContext* ctx, uint32_t ssrc,
	int32_t roc, int64_t keyDerivRate);

	/**
	* Perform key derivation according to SRTP specification
	*
	* This method computes the session key, session authentication key and the
	* session salt key. This method must be called at least once after the
	* SRTP Cryptograhic context was set up.
	*
	* @param ctx
	* The ZsrtpContext
	* @param index
	* The 48 bit SRTP packet index. See the <code>guessIndex</code>
	* method.
	*/
	void zsrtp_deriveSrtpKeys(ZsrtpContext* ctx, uint64_t index);

	-
	+#ifdef __cplusplus
	+ typedef class CryptoContextCtrl CryptoContextCtrl;
	+#else
	typedef struct CryptoContextCtrl CryptoContextCtrl;
	+#endif

	typedef struct zsrtcpContext
	{
	CryptoContextCtrl* srtcp;
	void* userData;
	uint32_t srtcpIndex;
	} ZsrtpContextCtrl;

	/**
	* Constructor for an active SRTP cryptographic context.
	*
	* This constructor creates an active SRTP cryptographic context were
	* algorithms are enabled, keys are computed and so on. This SRTP
	* cryptographic context can protect a RTP SSRC stream.
	*
	* @param ssrc
	* The RTP SSRC that this SRTP cryptographic context protects.
	*
	* @param ealg
	* The encryption algorithm to use. Possible values are <code>
	* SrtpEncryptionNull, SrtpEncryptionAESCM, SrtpEncryptionAESF8
	* </code>. See chapter 4.1.1 for AESCM (Counter mode) and 4.1.2
	* for AES F8 mode.
	*
	* @param aalg
	* The authentication algorithm to use. Possible values are <code>
	* SrtpEncryptionNull, SrtpAuthenticationSha1Hmac</code>. The only
	* active algorithm here is SHA1 HMAC, a SHA1 based hashed message
	* authentication code as defined in RFC 2104.
	*
	* @param masterKey
	* Pointer to the master key for this SRTP cryptographic context.
	* Must point to <code>masterKeyLength</code> bytes. Refer to chapter
	* 3.2.1 of the RFC about the role of the master key.
	*
	* @param masterKeyLength
	* The length in bytes of the master key in bytes. The length must
	* match the selected encryption algorithm. Because SRTP uses AES
	* based encryption only, then master key length may be 16 or 32
	* bytes (128 or 256 bit master key)
	*
	* @param masterSalt
	* SRTP uses the master salt to computer the initialization vector
	* that in turn is input to compute the session key, session
	* authentication key and the session salt.
	*
	* @param masterSaltLength
	* The length in bytes of the master salt data in bytes. SRTP uses
	* AES as encryption algorithm. AES encrypts 16 byte blocks
	* (independent of the key length). According to RFC3711 the standard
	* value for the master salt length should be 112 bit (14 bytes).
	*
	* @param ekeyl
	* The length in bytes of the session encryption key that SRTP shall
	* compute and use. Usually the same length as for the master key
	* length. But you may use a different length as well. Be carefull
	* that the key management mechanisms supports different key lengths.
	*
	* @param akeyl
	* The length in bytes of the session authentication key. SRTP
	* computes this key and uses it as input to the authentication
	* algorithm.
	* The standard value is 160 bits (20 bytes).
	*
	* @param skeyl
	* The length in bytes of the session salt. SRTP computes this salt
	* key and uses it as input during encryption. The length usually
	* is the same as the master salt length.
	*
	* @param tagLength
	* The length is bytes of the authentication tag that SRTP appends
	* to the RTP packet. Refer to chapter 4.2. in the RFC 3711.
	*/
	ZsrtpContextCtrl* zsrtp_CreateWrapperCtrl( uint32_t ssrc,
	const int32_t ealg,
	const int32_t aalg,
	uint8_t* masterKey,
	int32_t masterKeyLength,
	uint8_t* masterSalt,
	int32_t masterSaltLength,
	int32_t ekeyl,
	int32_t akeyl,
	int32_t skeyl,
	int32_t tagLength );

	/**
	* Destroy a ZSRTCP wrapper Context
	*
	* @param ctx
	* A ZSRTCP wrapper context.
	*/
	void zsrtp_DestroyWrapperCtrl (ZsrtpContextCtrl* ctx);

	/**
	* Encrypt the RTCP payload and compute authentication code.
	*
	* The method requires a ready made RTCP packet in the RTCP packet data
	* buffer.
	*
	* The method computes an authentication code and appends this code to the
	* buffer and computes a new length. The RTCP packet buffer must be large
	* enough to hold this authentication code.
	*
	* @param ctx
	* The ZsrtpContextCtrl
	*
	* @param buffer
	* Pointer to the data that contains the RTP packet data. SRTP appends
	* the authentication code to the encrypted RTP packet data.
	*
	* @param length
	* Length of the RTCP data buffer.
	*
	* @param newLength
	* The new length of the RTCP data buffer including authentication code
	*
	* @returns
	* 0 if no active SRTCP crypto context, 1 if data is encrypted.
	*/
	int32_t zsrtp_protectCtrl(ZsrtpContextCtrl* ctx, uint8_t* buffer, int32_t length,
	int32_t* newLength);

	/**
	* Decrypt the RTCP payload and check authentication code.
	*
	* The method requires a SRTCP packet in the SRTP packet data
	* buffer.
	*
	* SRTP checks SRTP packet replay, then it computes the authentication
	* code and checks if the authentication code is correct. If the checks
	* are ok then SRTP decrypts the payload data.
	*
	* @param ctx
	* The ZsrtpContextCtrl
	*
	* @param buffer
	* Pointer to the data that contains the SRTCP packet data. SRTCP remove
	* the authentication code from the decrypted RTCP packet data.
	*
	* @param length
	* Length of the RTP data buffer.
	*
	* @param newLength
	* The new length of the RTCP data buffer excluding authentication code
	*
	* @returns
	* 0 if no active SRTCP crypto context, 1 if data is decrypted,
	* -1 if data authentication failed, -2 if SRTCP replay check failed
	*/
	int32_t zsrtp_unprotectCtrl(ZsrtpContextCtrl* ctx, uint8_t* buffer, int32_t length,
	int32_t* newLength);

	/**
	* Derive a new Crypto Context for use with a new SSRC
	*
	* This method stores a new Crypto Context initialized with the data
	* of this crypto context. Replacing the SSRC, Roll-over-Counter, and
	* the key derivation rate the application cab use this Crypto Context
	* to encrypt / decrypt a new stream (Synchronization source) inside
	* one RTP session.
	*
	* Before the application can use this crypto context it must call
	* the <code>deriveSrtpKeys</code> method.
	*
	* @param ctx
	* The ZsrtpContextCtrl
	* @param ssrc
	* The SSRC for this context
	*/
	void zsrtp_newCryptoContextForSSRCCtrl(ZsrtpContextCtrl* ctx, uint32_t ssrc);

	/**
	* Perform key derivation according to SRTP specification
	*
	* This method computes the session key, session authentication key and the
	* session salt key. This method must be called at least once after the
	* SRTP Cryptograhic context was set up.
	*
	* @param ctx
	* The ZsrtpContextCtrl
	*/
	void zsrtp_deriveSrtpKeysCtrl(ZsrtpContextCtrl* ctx);


	#ifdef __cplusplus
	}
	#endif
	/**
	* @}
	*/
	#endif
	diff --git a/deps/pjsip/third_party/zsrtp/zrtp/srtp/crypto/openssl/SrtpSymCrypto.cpp b/deps/pjsip/third_party/zsrtp/zrtp/srtp/crypto/openssl/SrtpSymCrypto.cpp
	index 00d44768..5a64d327 100644
	--- a/deps/pjsip/third_party/zsrtp/zrtp/srtp/crypto/openssl/SrtpSymCrypto.cpp
	+++ b/deps/pjsip/third_party/zsrtp/zrtp/srtp/crypto/openssl/SrtpSymCrypto.cpp
	@@ -1,315 +1,323 @@
	/*
	Copyright (C) 2012 Werner Dittmann

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

	* In addition, as a special exception, the copyright holders give
	* permission to link the code of portions of this program with the
	* OpenSSL library under certain conditions as described in each
	* individual source file, and distribute linked combinations
	* including the two.
	* You must obey the GNU General Public License in all respects
	* for all of the code used other than OpenSSL. If you modify
	* file(s) with this exception, you may extend this exception to your
	* version of the file(s), but you are not obligated to do so. If you
	* do not wish to do so, delete this exception statement from your
	* version. If you delete this exception statement from all source
	* files in the program, then also delete it here.
	*/

	/**
	* @author Werner Dittmann <Werner.Dittmann@t-online.de>
	*/

	#define MAKE_F8_TEST

	#include <stdlib.h>
	#include <openssl/aes.h> // the include of openSSL
	#include <crypto/SrtpSymCrypto.h>
	#include <cryptcommon/twofish.h>
	#include <string.h>
	#include <stdio.h>
	#include <common/osSpecifics.h>

	+#if defined(__APPLE__)
	+# pragma GCC diagnostic push
	+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
	+#endif
	+
	SrtpSymCrypto::SrtpSymCrypto(int algo):key(NULL), algorithm(algo) {
	}

	SrtpSymCrypto::SrtpSymCrypto( uint8_t* k, int32_t keyLength, int algo ):
	key(NULL), algorithm(algo) {

	setNewKey(k, keyLength);
	}

	SrtpSymCrypto::~SrtpSymCrypto() {
	if (key != NULL) {
	if (algorithm == SrtpEncryptionAESCM \|\| algorithm == SrtpEncryptionAESF8) {
	memset(key, 0, sizeof(AES_KEY) );
	}
	else if (algorithm == SrtpEncryptionTWOCM \|\| algorithm == SrtpEncryptionTWOF8) {
	memset(key, 0, sizeof(Twofish_key));
	}
	delete[] (uint8_t*)key;
	key = NULL;
	}
	}

	static int twoFishInit = 0;

	bool SrtpSymCrypto::setNewKey(const uint8_t* k, int32_t keyLength) {
	// release an existing key before setting a new one
	if (key != NULL)
	delete[] (uint8_t*)key;

	if (!(keyLength == 16 \|\| keyLength == 32)) {
	return false;
	}
	if (algorithm == SrtpEncryptionAESCM \|\| algorithm == SrtpEncryptionAESF8) {
	key = new uint8_t[sizeof(AES_KEY)];
	memset(key, 0, sizeof(AES_KEY) );
	AES_set_encrypt_key(k, keyLength8, (AES_KEY )key);
	}
	else if (algorithm == SrtpEncryptionTWOCM \|\| algorithm == SrtpEncryptionTWOF8) {
	if (!twoFishInit) {
	Twofish_initialise();
	twoFishInit = 1;
	}
	key = new uint8_t[sizeof(Twofish_key)];
	memset(key, 0, sizeof(Twofish_key));
	Twofish_prepare_key((Twofish_Byte)k, keyLength, (Twofish_key)key);
	}
	else
	return false;

	return true;
	}


	void SrtpSymCrypto::encrypt(const uint8_t* input, uint8_t* output ) {
	if (algorithm == SrtpEncryptionAESCM \|\| algorithm == SrtpEncryptionAESF8) {
	AES_encrypt(input, output, (AES_KEY *)key);
	}
	else if (algorithm == SrtpEncryptionTWOCM \|\| algorithm == SrtpEncryptionTWOF8) {
	Twofish_encrypt((Twofish_key)key, (Twofish_Byte)input,
	(Twofish_Byte*)output);
	}
	}

	void SrtpSymCrypto::get_ctr_cipher_stream(uint8_t* output, uint32_t length,
	uint8_t* iv ) {
	uint16_t ctr = 0;
	unsigned char temp[SRTP_BLOCK_SIZE];

	for(ctr = 0; ctr < length/SRTP_BLOCK_SIZE; ctr++) {
	//compute the cipher stream
	iv[14] = (uint8_t)((ctr & 0xFF00) >> 8);
	iv[15] = (uint8_t)((ctr & 0x00FF));

	encrypt(iv, &output[ctr*SRTP_BLOCK_SIZE]);
	}
	if ((length % SRTP_BLOCK_SIZE) > 0) {
	// Treat the last bytes:
	iv[14] = (uint8_t)((ctr & 0xFF00) >> 8);
	iv[15] = (uint8_t)((ctr & 0x00FF));

	encrypt(iv, temp);
	memcpy(&output[ctr*SRTP_BLOCK_SIZE], temp, length % SRTP_BLOCK_SIZE );
	}
	}

	void SrtpSymCrypto::ctr_encrypt(const uint8_t* input, uint32_t input_length,
	uint8_t* output, uint8_t* iv ) {

	if (key == NULL)
	return;

	uint16_t ctr = 0;
	unsigned char temp[SRTP_BLOCK_SIZE];

	int l = input_length/SRTP_BLOCK_SIZE;
	for (ctr = 0; ctr < l; ctr++ ) {
	iv[14] = (uint8_t)((ctr & 0xFF00) >> 8);
	iv[15] = (uint8_t)((ctr & 0x00FF));

	encrypt(iv, temp);
	for (int i = 0; i < SRTP_BLOCK_SIZE; i++ ) {
	output++ = temp[i] ^ input++;
	}

	}
	l = input_length % SRTP_BLOCK_SIZE;
	if (l > 0) {
	// Treat the last bytes:
	iv[14] = (uint8_t)((ctr & 0xFF00) >> 8);
	iv[15] = (uint8_t)((ctr & 0x00FF));

	encrypt(iv, temp);
	for (int i = 0; i < l; i++ ) {
	output++ = temp[i] ^ input++;
	}
	}
	}

	void SrtpSymCrypto::ctr_encrypt( uint8_t* data, uint32_t data_length, uint8_t* iv ) {

	if (key == NULL)
	return;

	uint16_t ctr = 0;
	unsigned char temp[SRTP_BLOCK_SIZE];

	int l = data_length/SRTP_BLOCK_SIZE;
	for (ctr = 0; ctr < l; ctr++ ) {
	iv[14] = (uint8_t)((ctr & 0xFF00) >> 8);
	iv[15] = (uint8_t)((ctr & 0x00FF));

	encrypt(iv, temp);
	for (int i = 0; i < SRTP_BLOCK_SIZE; i++ ) {
	*data++ ^= temp[i];
	}

	}
	l = data_length % SRTP_BLOCK_SIZE;
	if (l > 0) {
	// Treat the last bytes:
	iv[14] = (uint8_t)((ctr & 0xFF00) >> 8);
	iv[15] = (uint8_t)((ctr & 0x00FF));

	encrypt(iv, temp);
	for (int i = 0; i < l; i++ ) {
	*data++ ^= temp[i];
	}
	}
	}

	void SrtpSymCrypto::f8_encrypt(const uint8_t* data, uint32_t data_length,
	uint8_t* iv, SrtpSymCrypto* f8Cipher ) {

	f8_encrypt(data, data_length, const_cast<uint8_t*>(data), iv, f8Cipher);
	}

	#define MAX_KEYLEN 32

	void SrtpSymCrypto::f8_deriveForIV(SrtpSymCrypto* f8Cipher, uint8_t* key, int32_t keyLen,
	uint8_t* salt, int32_t saltLen) {

	unsigned char cp_in, cp_in1, *cp_out;

	unsigned char maskedKey[MAX_KEYLEN];
	unsigned char saltMask[MAX_KEYLEN];

	if (keyLen > MAX_KEYLEN)
	return;

	if (saltLen > keyLen)
	return;
	/*
	* First copy the salt into the mask field, then fill with 0x55 to
	* get a full key.
	*/
	memcpy(saltMask, salt, saltLen);
	memset(saltMask+saltLen, 0x55, keyLen-saltLen);

	/*
	* XOR the original key with the above created mask to
	* get the special key.
	*/
	cp_out = maskedKey;
	cp_in = key;
	cp_in1 = saltMask;
	for (int i = 0; i < keyLen; i++) {
	cp_out++ = cp_in++ ^ *cp_in1++;
	}
	/*
	* Prepare the a new AES cipher with the special key to compute IV'
	*/
	f8Cipher->setNewKey(maskedKey, keyLen);
	}

	void SrtpSymCrypto::f8_encrypt(const uint8_t* in, uint32_t in_length, uint8_t* out,
	uint8_t* iv, SrtpSymCrypto* f8Cipher ) {


	int offset = 0;

	unsigned char ivAccent[SRTP_BLOCK_SIZE];
	unsigned char S[SRTP_BLOCK_SIZE];

	F8_CIPHER_CTX f8ctx;

	if (key == NULL)
	return;
	/*
	* Get memory for the derived IV (IV')
	*/
	f8ctx.ivAccent = ivAccent;
	/*
	* Use the derived IV encryption setup to encrypt the original IV to produce IV'.
	*/
	f8Cipher->encrypt(iv, f8ctx.ivAccent);

	f8ctx.J = 0; // initialize the counter
	f8ctx.S = S; // get the key stream buffer

	memset(f8ctx.S, 0, SRTP_BLOCK_SIZE); // initial value for key stream

	while (in_length >= SRTP_BLOCK_SIZE) {
	processBlock(&f8ctx, in+offset, SRTP_BLOCK_SIZE, out+offset);
	in_length -= SRTP_BLOCK_SIZE;
	offset += SRTP_BLOCK_SIZE;
	}
	if (in_length > 0) {
	processBlock(&f8ctx, in+offset, in_length, out+offset);
	}
	}

	int SrtpSymCrypto::processBlock(F8_CIPHER_CTX f8ctx, const uint8_t in, int32_t length, uint8_t* out) {

	int i;
	const uint8_t *cp_in;
	uint8_t* cp_in1, *cp_out;
	uint32_t *ui32p;

	/*
	* XOR the previous key stream with IV'
	* ( S(-1) xor IV' )
	*/
	cp_in = f8ctx->ivAccent;
	cp_out = f8ctx->S;
	for (i = 0; i < SRTP_BLOCK_SIZE; i++) {
	cp_out++ ^= cp_in++;
	}
	/*
	* Now XOR (S(n-1) xor IV') with the current counter, then increment the counter
	*/
	ui32p = (uint32_t *)f8ctx->S;
	ui32p[3] ^= zrtpHtonl(f8ctx->J);
	f8ctx->J++;
	/*
	* Now compute the new key stream using AES encrypt
	*/
	encrypt(f8ctx->S, f8ctx->S);
	/*
	* as the last step XOR the plain text with the key stream to produce
	* the ciphertext.
	*/
	cp_out = out;
	cp_in = in;
	cp_in1 = f8ctx->S;
	for (i = 0; i < length; i++) {
	cp_out++ = cp_in++ ^ *cp_in1++;
	}
	return length;
	}

	+#if defined(__APPLE__)
	+# pragma GCC diagnostic pop
	+#endif
	diff --git a/deps/pjsip/third_party/zsrtp/zrtp/srtp/crypto/openssl/hmac.cpp b/deps/pjsip/third_party/zsrtp/zrtp/srtp/crypto/openssl/hmac.cpp
	index 93a6d0d7..6cdb6b14 100644
	--- a/deps/pjsip/third_party/zsrtp/zrtp/srtp/crypto/openssl/hmac.cpp
	+++ b/deps/pjsip/third_party/zsrtp/zrtp/srtp/crypto/openssl/hmac.cpp
	@@ -1,113 +1,122 @@
	/*
	Copyright (C) 2010 Werner Dittmann

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

	* In addition, as a special exception, the copyright holders give
	* permission to link the code of portions of this program with the
	* OpenSSL library under certain conditions as described in each
	* individual source file, and distribute linked combinations
	* including the two.
	* You must obey the GNU General Public License in all respects
	* for all of the code used other than OpenSSL. If you modify
	* file(s) with this exception, you may extend this exception to your
	* version of the file(s), but you are not obligated to do so. If you
	* do not wish to do so, delete this exception statement from your
	* version. If you delete this exception statement from all source
	* files in the program, then also delete it here.
	*/

	/*
	* Authors: Werner Dittmann
	*/

	#include <stdint.h>
	#include <openssl/hmac.h>
	#include <crypto/hmac.h>

	+#if defined(__APPLE__)
	+# pragma GCC diagnostic push
	+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
	+#endif
	+
	void hmac_sha1(uint8_t * key, int32_t key_length,
	const uint8_t* data, uint32_t data_length,
	uint8_t* mac, int32_t* mac_length )
	{
	HMAC(EVP_sha1(), key, key_length,
	data, data_length, mac,
	reinterpret_cast<uint32_t*>(mac_length) );
	}

	void hmac_sha1( uint8_t* key, int32_t key_length,
	const uint8_t* data_chunks[],
	uint32_t data_chunck_length[],
	uint8_t* mac, int32_t* mac_length ) {
	HMAC_CTX ctx;
	HMAC_CTX_init(&ctx);
	HMAC_Init_ex(&ctx, key, key_length, EVP_sha1(), NULL);
	while (*data_chunks) {
	HMAC_Update(&ctx, data_chunks, data_chunck_length);
	data_chunks ++;
	data_chunck_length ++;
	}
	HMAC_Final(&ctx, mac, reinterpret_cast<uint32_t*>(mac_length));
	HMAC_CTX_cleanup(&ctx);
	}

	void* createSha1HmacContext(uint8_t* key, int32_t key_length)
	{
	HMAC_CTX* ctx = (HMAC_CTX*)malloc(sizeof(HMAC_CTX));

	HMAC_CTX_init(ctx);
	HMAC_Init_ex(ctx, key, key_length, EVP_sha1(), NULL);
	return ctx;
	}

	void* initializeSha1HmacContext(void* ctx, uint8_t* key, int32_t keyLength)
	{
	HMAC_CTX pctx = (HMAC_CTX)ctx;

	HMAC_CTX_init(pctx);
	HMAC_Init_ex(pctx, key, keyLength, EVP_sha1(), NULL);
	return pctx;
	}

	void hmacSha1Ctx(void* ctx, const uint8_t* data, uint32_t data_length,
	uint8_t* mac, int32_t* mac_length)
	{
	HMAC_CTX* pctx = (HMAC_CTX*)ctx;

	HMAC_Init_ex(pctx, NULL, 0, NULL, NULL );
	HMAC_Update(pctx, data, data_length );
	HMAC_Final(pctx, mac, reinterpret_cast<uint32_t*>(mac_length) );
	}

	void hmacSha1Ctx(void* ctx, const uint8_t* data[], uint32_t data_length[],
	uint8_t* mac, int32_t* mac_length )
	{
	HMAC_CTX* pctx = (HMAC_CTX*)ctx;

	HMAC_Init_ex(pctx, NULL, 0, NULL, NULL );
	while (*data) {
	HMAC_Update(pctx, data, data_length);
	data++;
	data_length++;
	}
	HMAC_Final(pctx, mac, reinterpret_cast<uint32_t*>(mac_length) );
	}

	void freeSha1HmacContext(void* ctx)
	{
	if (ctx) {
	HMAC_CTX_cleanup((HMAC_CTX*)ctx);
	free(ctx);
	}
	-}
	\ No newline at end of file
	+}
	+
	+#if defined(__APPLE__)
	+# pragma GCC diagnostic pop
	+#endif
	diff --git a/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/InitializeOpenSSL.cpp b/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/InitializeOpenSSL.cpp
	index b23cabd6..aef6dc58 100644
	--- a/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/InitializeOpenSSL.cpp
	+++ b/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/InitializeOpenSSL.cpp
	@@ -1,237 +1,246 @@
	/*
	Copyright (C) 2006-2013 Werner Dittmann

	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU Lesser General Public License as published by
	the Free Software Foundation; either version 2, or (at your option)
	any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Boston, MA 02111.
	*/

	#include <stdio.h>
	#include <openssl/evp.h>
	#include <config.h>

	#ifdef _MSWINDOWS_
	#include <windows.h>
	#endif
	#if defined SOLARIS && !defined HAVE_PTHREAD_H
	#include <synch.h>
	#include <thread.h>
	#endif
	#if !defined _MSWINDOWS_ && !defined SOLARIS
	#include <pthread.h>
	#endif

	#ifdef const
	#undef const
	#endif

	+#if defined(__APPLE__)
	+# pragma GCC diagnostic push
	+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
	+#endif
	+
	+
	static void threadLockSetup(void);
	static void threadLockCleanup(void);
	static void myLockingCallback(int, int, const char *, int);

	/**
	* Implement the locking callback functions for openSSL.
	*
	* Unfortunatly we can't use the Commonc++ Mutex here because the
	* Mutex may use (for some cases) the Commonc++ Thread class. OpenSSL
	* does not use this Thread class.
	*/

	static int initialized = 0;

	int initializeOpenSSL ()
	{

	if (initialized) {
	return 1;
	}
	initialized = 1;
	threadLockSetup();
	return 1;
	}

	int finalizeOpenSSL ()
	{
	if(!initialized)
	return 1;

	initialized = 0;
	threadLockCleanup();
	return 1;
	}

	#ifdef _MSWINDOWS_

	static HANDLE *lock_cs;

	static void threadLockSetup(void) {
	int i;

	lock_cs=(HANDLE)OPENSSL_malloc(CRYPTO_num_locks() sizeof(HANDLE));
	for (i = 0; i < CRYPTO_num_locks(); i++) {
	lock_cs[i] = CreateMutex(NULL,FALSE,NULL);
	}

	CRYPTO_set_locking_callback((void ()(int,int,const char ,int))myLockingCallback);
	/* id callback defined */
	}

	static void threadLockCleanup(void) {
	int i;

	CRYPTO_set_locking_callback(NULL);
	for (i = 0; i < CRYPTO_num_locks(); i++) {
	CloseHandle(lock_cs[i]);
	}
	OPENSSL_free(lock_cs);
	}

	static void myLockingCallback(int mode, int type, const char *file, int line) {
	if (mode & CRYPTO_LOCK) {
	WaitForSingleObject(lock_cs[type], INFINITE);
	}
	else {
	ReleaseMutex(lock_cs[type]);
	}
	}

	#endif /* OPENSSL_SYS_WIN32 */


	#if defined SOLARIS && !defined HAVE_PTHREAD_H

	static mutex_t *lock_cs;
	static long *lock_count;

	static void threadLockSetup(void) {
	int i;

	lock_cs = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(mutex_t));
	lock_count = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
	for (i = 0; i < CRYPTO_num_locks(); i++) {
	lock_count[i] = 0;
	/* rwlock_init(&(lock_cs[i]),USYNC_THREAD,NULL); */
	mutex_init(&(lock_cs[i]), USYNC_THREAD, NULL);
	}
	CRYPTO_set_locking_callback((void ()(int, int ,const char , int))myLockingCallback);
	}

	static void threadLockCleanup(void) {
	int i;

	CRYPTO_set_locking_callback(NULL);

	fprintf(stderr,"cleanup\n");

	for (i = 0; i < CRYPTO_num_locks(); i++) {
	/* rwlock_destroy(&(lock_cs[i])); */
	mutex_destroy(&(lock_cs[i]));
	fprintf(stderr,"%8ld:%s\n",lock_count[i],CRYPTO_get_lock_name(i));
	}
	OPENSSL_free(lock_cs);
	OPENSSL_free(lock_count);
	}

	static void myLockingCallback(int mode, int type, const char *file, int line)
	{
	#ifdef undef
	fprintf(stderr,"thread=%4d mode=%s lock=%s %s:%d\n",
	CRYPTO_thread_id(),
	(mode&CRYPTO_LOCK)?"l":"u",
	(type&CRYPTO_READ)?"r":"w",file,line);
	#endif

	/*
	if (CRYPTO_LOCK_SSL_CERT == type)
	fprintf(stderr,"(t,m,f,l) %ld %d %s %d\n",
	CRYPTO_thread_id(),
	mode,file,line);
	*/
	if (mode & CRYPTO_LOCK) {
	mutex_lock(&(lock_cs[type]));
	lock_count[type]++;
	}
	else {
	mutex_unlock(&(lock_cs[type]));
	}
	}

	static unsigned long solaris_thread_id(void) {
	unsigned long ret;

	ret=(unsigned long)thr_self();
	return(ret);
	}
	#endif /* SOLARIS */

	#if !defined _MSWINDOWS_ && !defined SOLARIS

	static pthread_mutex_t* lock_cs;
	static long* lock_count;

	static void threadLockSetup(void) {
	int i;

	lock_cs = (pthread_mutex_t)OPENSSL_malloc(CRYPTO_num_locks() sizeof(pthread_mutex_t));
	lock_count = (long)OPENSSL_malloc(CRYPTO_num_locks() sizeof(long));
	for (i = 0; i < CRYPTO_num_locks(); i++) {
	lock_count[i] = 0;
	pthread_mutex_init(&(lock_cs[i]),NULL);
	}

	// CRYPTO_set_id_callback((unsigned long (*)())pthreads_thread_id);
	CRYPTO_set_locking_callback((void ()(int,int,const char , int))myLockingCallback);
	}

	static void threadLockCleanup(void)
	{
	int i;

	CRYPTO_set_locking_callback(NULL);
	fprintf(stderr,"cleanup\n");
	for (i = 0; i < CRYPTO_num_locks(); i++) {
	pthread_mutex_destroy(&(lock_cs[i]));
	fprintf(stderr,"%8ld:%s\n",lock_count[i],
	CRYPTO_get_lock_name(i));
	}
	OPENSSL_free(lock_cs);
	OPENSSL_free(lock_count);
	}

	static void myLockingCallback(int mode, int type, const char *file,
	int line) {
	#ifdef undef
	fprintf(stderr,"thread=%4d mode=%s lock=%s %s:%d\n",
	CRYPTO_thread_id(),
	(mode&CRYPTO_LOCK)?"l":"u",
	(type&CRYPTO_READ)?"r":"w",file,line);
	#endif
	if (mode & CRYPTO_LOCK) {
	pthread_mutex_lock(&(lock_cs[type]));
	lock_count[type]++;
	}
	else {
	pthread_mutex_unlock(&(lock_cs[type]));
	}
	}
	#endif /* !defined _MSWINDOWS_ && !defined SOLARIS */
	/*
	static unsigned long pthreads_thread_id(void)
	{
	unsigned long ret;

	ret = (unsigned long)pthread_self();
	return(ret);
	}
	*/

	+#if defined(__APPLE__)
	+# pragma GCC diagnostic pop
	+#endif
	diff --git a/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/aesCFB.cpp b/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/aesCFB.cpp
	index bac29f5c..114893b5 100644
	--- a/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/aesCFB.cpp
	+++ b/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/aesCFB.cpp
	@@ -1,89 +1,97 @@
	/*
	Copyright (C) 2006, 2007 by Werner Dittmann

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

	* In addition, as a special exception, the copyright holders give
	* permission to link the code of portions of this program with the
	* OpenSSL library under certain conditions as described in each
	* individual source file, and distribute linked combinations
	* including the two.
	* You must obey the GNU General Public License in all respects
	* for all of the code used other than OpenSSL. If you modify
	* file(s) with this exception, you may extend this exception to your
	* version of the file(s), but you are not obligated to do so. If you
	* do not wish to do so, delete this exception statement from your
	* version. If you delete this exception statement from all source
	* files in the program, then also delete it here.
	*/

	/** Copyright (C) 2006, 2007
	*
	* @author Werner Dittmann <Werner.Dittmann@t-online.de>
	*/

	#include <openssl/crypto.h>
	#include <openssl/aes.h>
	#include <string.h>

	#include <zrtp/crypto/aesCFB.h>

	-// extern void initializeOpenSSL();
	+#if defined(__APPLE__)
	+# pragma GCC diagnostic push
	+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
	+#endif

	+// extern void initializeOpenSSL();

	void aesCfbEncrypt(uint8_t* key, int32_t keyLength, uint8_t* IV, uint8_t *data,
	int32_t dataLength)
	{
	AES_KEY aesKey;
	int usedBytes = 0;

	// initializeOpenSSL();

	memset(&aesKey, 0, sizeof( AES_KEY ) );
	if (keyLength == 16) {
	AES_set_encrypt_key(key, 128, &aesKey);
	}
	else if (keyLength == 32) {
	AES_set_encrypt_key(key, 256, &aesKey);
	}
	else {
	return;
	}
	AES_cfb128_encrypt(data, data, dataLength, &aesKey,
	IV, &usedBytes, AES_ENCRYPT);
	}


	void aesCfbDecrypt(uint8_t* key, int32_t keyLength, uint8_t* IV, uint8_t *data,
	int32_t dataLength)
	{
	AES_KEY aesKey;
	int usedBytes = 0;

	// initializeOpenSSL();

	memset(&aesKey, 0, sizeof( AES_KEY ) );
	if (keyLength == 16) {
	AES_set_encrypt_key(key, 128, &aesKey);
	}
	else if (keyLength == 32) {
	AES_set_encrypt_key(key, 256, &aesKey);
	}
	else {
	return;
	}
	AES_cfb128_encrypt(data, data, dataLength, &aesKey,
	IV, &usedBytes, AES_DECRYPT);
	}
	+
	+#if defined(__APPLE__)
	+# pragma GCC diagnostic pop
	+#endif
	diff --git a/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/hmac256.cpp b/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/hmac256.cpp
	index 40e4e823..0953ad5c 100644
	--- a/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/hmac256.cpp
	+++ b/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/hmac256.cpp
	@@ -1,67 +1,76 @@
	/*
	Copyright (C) 2005, 2004 Erik Eliasson, Johan Bilien

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

	* In addition, as a special exception, the copyright holders give
	* permission to link the code of portions of this program with the
	* OpenSSL library under certain conditions as described in each
	* individual source file, and distribute linked combinations
	* including the two.
	* You must obey the GNU General Public License in all respects
	* for all of the code used other than OpenSSL. If you modify
	* file(s) with this exception, you may extend this exception to your
	* version of the file(s), but you are not obligated to do so. If you
	* do not wish to do so, delete this exception statement from your
	* version. If you delete this exception statement from all source
	* files in the program, then also delete it here.

	*/

	/*
	* Authors: Erik Eliasson <eliasson@it.kth.se>
	* Johan Bilien <jobi@via.ecp.fr>
	*/

	#include <openssl/hmac.h>
	#include <crypto/hmac256.h>

	+#if defined(__APPLE__)
	+# pragma GCC diagnostic push
	+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
	+#endif
	+
	void hmac_sha256(uint8_t* key, uint32_t key_length,
	uint8_t* data, int32_t data_length,
	uint8_t* mac, uint32_t* mac_length)
	{
	unsigned int tmp;
	HMAC( EVP_sha256(), key, key_length, data, data_length, mac, &tmp );
	*mac_length = tmp;
	}

	void hmac_sha256(uint8_t* key, uint32_t key_length,
	uint8_t* data_chunks[],
	uint32_t data_chunck_length[],
	uint8_t* mac, uint32_t* mac_length )
	{
	unsigned int tmp;
	HMAC_CTX ctx;
	HMAC_CTX_init( &ctx );
	HMAC_Init_ex( &ctx, key, key_length, EVP_sha256(), NULL );
	while( *data_chunks ){
	HMAC_Update( &ctx, data_chunks, data_chunck_length );
	data_chunks ++;
	data_chunck_length ++;
	}
	HMAC_Final( &ctx, mac, &tmp);
	*mac_length = tmp;
	HMAC_CTX_cleanup( &ctx );
	}
	+
	+#if defined(__APPLE__)
	+# pragma GCC diagnostic pop
	+#endif
	diff --git a/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/hmac384.cpp b/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/hmac384.cpp
	index 8181cd66..f1dd5abc 100644
	--- a/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/hmac384.cpp
	+++ b/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/hmac384.cpp
	@@ -1,65 +1,74 @@
	/*
	Copyright (C) 2005, 2004 Erik Eliasson, Johan Bilien

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

	* In addition, as a special exception, the copyright holders give
	* permission to link the code of portions of this program with the
	* OpenSSL library under certain conditions as described in each
	* individual source file, and distribute linked combinations
	* including the two.
	* You must obey the GNU General Public License in all respects
	* for all of the code used other than OpenSSL. If you modify
	* file(s) with this exception, you may extend this exception to your
	* version of the file(s), but you are not obligated to do so. If you
	* do not wish to do so, delete this exception statement from your
	* version. If you delete this exception statement from all source
	* files in the program, then also delete it here.

	*/

	/*
	* Authors: Erik Eliasson <eliasson@it.kth.se>
	* Johan Bilien <jobi@via.ecp.fr>
	*/

	#include <openssl/hmac.h>
	#include <zrtp/crypto/hmac256.h>

	+#if defined(__APPLE__)
	+# pragma GCC diagnostic push
	+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
	+#endif
	+
	void hmac_sha384(uint8_t* key, uint32_t key_length, uint8_t* data, int32_t data_length, uint8_t* mac, uint32_t* mac_length)
	{
	unsigned int tmp;
	HMAC( EVP_sha384(), key, key_length, data, data_length, mac, &tmp );
	*mac_length = tmp;
	}

	void hmac_sha384(uint8_t* key, uint32_t key_length,
	uint8_t* data_chunks[],
	uint32_t data_chunck_length[],
	uint8_t* mac, uint32_t* mac_length )
	{
	unsigned int tmp;
	HMAC_CTX ctx;
	HMAC_CTX_init( &ctx );
	HMAC_Init_ex( &ctx, key, key_length, EVP_sha384(), NULL );
	while( *data_chunks ){
	HMAC_Update( &ctx, data_chunks, data_chunck_length );
	data_chunks ++;
	data_chunck_length ++;
	}
	HMAC_Final( &ctx, mac, &tmp);
	*mac_length = tmp;
	HMAC_CTX_cleanup( &ctx );
	}
	+
	+#if defined(__APPLE__)
	+# pragma GCC diagnostic pop
	+#endif
	diff --git a/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/sha256.cpp b/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/sha256.cpp
	index c46d7f85..69ecc7a8 100644
	--- a/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/sha256.cpp
	+++ b/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/sha256.cpp
	@@ -1,114 +1,123 @@
	/*
	Copyright (C) 2005, 2004 Erik Eliasson, Johan Bilien

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

	* In addition, as a special exception, the copyright holders give
	* permission to link the code of portions of this program with the
	* OpenSSL library under certain conditions as described in each
	* individual source file, and distribute linked combinations
	* including the two.
	* You must obey the GNU General Public License in all respects
	* for all of the code used other than OpenSSL. If you modify
	* file(s) with this exception, you may extend this exception to your
	* version of the file(s), but you are not obligated to do so. If you
	* do not wish to do so, delete this exception statement from your
	* version. If you delete this exception statement from all source
	* files in the program, then also delete it here.
	*/

	/**
	* @author Erik Eliasson <eliasson@it.kth.se>
	* Johan Bilien <jobi@via.ecp.fr>
	* Werner Dittmann <Werner.Dittmann@t-online.de>
	*/

	#include <openssl/crypto.h>
	#include <openssl/sha.h>

	#include <crypto/sha256.h>

	+#if defined(__APPLE__)
	+# pragma GCC diagnostic push
	+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
	+#endif
	+
	void sha256(unsigned char *data, unsigned int data_length,
	unsigned char *digest )
	{
	SHA256(data, data_length, digest);
	}

	void sha256(unsigned char * data_chunks[],
	unsigned int data_chunck_length[],
	unsigned char *digest)
	{
	SHA256_CTX ctx;
	SHA256_Init( &ctx);
	while(*data_chunks) {
	SHA256_Update(&ctx, data_chunks, data_chunck_length);
	data_chunks++;
	data_chunck_length++;
	}
	SHA256_Final(digest, &ctx);
	}

	void* createSha256Context()
	{
	SHA256_CTX* ctx = (SHA256_CTX*)malloc(sizeof (SHA256_CTX));
	if (ctx == NULL)
	return NULL;
	SHA256_Init(ctx);
	return (void*)ctx;
	}

	void closeSha256Context(void* ctx, unsigned char* digest)
	{
	SHA256_CTX* hd = (SHA256_CTX*)ctx;

	if (digest != NULL && hd != NULL) {
	SHA256_Final(digest, hd);
	}
	free(hd);
	}

	void* initializeSha256Context(void* ctx)
	{
	SHA256_CTX* hd = (SHA256_CTX*)ctx;
	SHA256_Init(hd);
	return (void*)hd;
	}

	void finalizeSha256Context(void* ctx, unsigned char* digest)
	{
	SHA256_CTX* hd = (SHA256_CTX*)ctx;
	if (digest != NULL && hd != NULL) {
	SHA256_Final(digest, hd);
	}
	}

	void sha256Ctx(void* ctx, unsigned char* data,
	unsigned int dataLength)
	{
	SHA256_CTX* hd = (SHA256_CTX*)ctx;
	SHA256_Update(hd, data, dataLength);
	}

	void sha256Ctx(void* ctx, unsigned char* dataChunks[],
	unsigned int dataChunkLength[])
	{
	SHA256_CTX* hd = (SHA256_CTX*)ctx;

	while (*dataChunks) {
	SHA256_Update (hd, dataChunks, dataChunkLength);
	dataChunks++;
	dataChunkLength++;
	}
	}
	+
	+#if defined(__APPLE__)
	+# pragma GCC diagnostic pop
	+#endif
	diff --git a/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/sha384.cpp b/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/sha384.cpp
	index 88946956..9b59dfe9 100644
	--- a/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/sha384.cpp
	+++ b/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/sha384.cpp
	@@ -1,115 +1,124 @@
	/*
	Copyright (C) 2005, 2004 Erik Eliasson, Johan Bilien

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

	* In addition, as a special exception, the copyright holders give
	* permission to link the code of portions of this program with the
	* OpenSSL library under certain conditions as described in each
	* individual source file, and distribute linked combinations
	* including the two.
	* You must obey the GNU General Public License in all respects
	* for all of the code used other than OpenSSL. If you modify
	* file(s) with this exception, you may extend this exception to your
	* version of the file(s), but you are not obligated to do so. If you
	* do not wish to do so, delete this exception statement from your
	* version. If you delete this exception statement from all source
	* files in the program, then also delete it here.
	*/

	/**
	* @author Erik Eliasson <eliasson@it.kth.se>
	* Johan Bilien <jobi@via.ecp.fr>
	* Werner Dittmann <Werner.Dittmann@t-online.de>
	*/

	#include <openssl/crypto.h>
	#include <openssl/sha.h>

	#include <crypto/sha384.h>

	+#if defined(__APPLE__)
	+# pragma GCC diagnostic push
	+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
	+#endif
	+
	void sha384(unsigned char *data, unsigned int data_length,
	unsigned char *digest )
	{
	SHA384(data, data_length, digest);
	}

	void sha384(unsigned char * data_chunks[],
	unsigned int data_chunck_length[],
	unsigned char *digest)
	{
	SHA512_CTX ctx;
	SHA384_Init( &ctx);
	while(*data_chunks) {
	SHA384_Update(&ctx, data_chunks, data_chunck_length);
	data_chunks++;
	data_chunck_length++;
	}
	SHA384_Final(digest, &ctx);
	}

	void* createSha384Context()
	{
	SHA512_CTX* ctx = (SHA512_CTX*)malloc(sizeof (SHA512_CTX));
	if (ctx == NULL)
	return NULL;
	SHA384_Init(ctx);
	return (void*)ctx;
	}

	void closeSha384Context(void* ctx, unsigned char* digest)
	{
	SHA512_CTX* hd = (SHA512_CTX*)ctx;

	if (digest != NULL) {
	SHA384_Final(digest, hd);
	}
	free(hd);
	}

	void* initializeSha384Context(void* ctx)
	{
	SHA512_CTX* hd = (SHA512_CTX*)ctx;
	SHA384_Init(hd);
	return (void*)hd;
	}

	void finalizeSha384Context(void* ctx, unsigned char* digest)
	{
	SHA512_CTX* hd = (SHA512_CTX*)ctx;

	if (digest != NULL) {
	SHA384_Final(digest, hd);
	}
	}

	void sha384Ctx(void* ctx, unsigned char* data,
	unsigned int dataLength)
	{
	SHA512_CTX* hd = (SHA512_CTX*)ctx;
	SHA384_Update(hd, data, dataLength);
	}

	void sha384Ctx(void* ctx, unsigned char* dataChunks[],
	unsigned int dataChunkLength[])
	{
	SHA512_CTX* hd = (SHA512_CTX*)ctx;

	while (*dataChunks) {
	SHA384_Update (hd, dataChunks, dataChunkLength);
	dataChunks++;
	dataChunkLength++;
	}
	}
	+
	+#if defined(__APPLE__)
	+# pragma GCC diagnostic pop
	+#endif
	diff --git a/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/zrtpDH.cpp b/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/zrtpDH.cpp
	index d5b8cc9b..2623d2a3 100644
	--- a/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/zrtpDH.cpp
	+++ b/deps/pjsip/third_party/zsrtp/zrtp/zrtp/crypto/openssl/zrtpDH.cpp
	@@ -1,426 +1,435 @@
	/*
	Copyright (C) 2006, 2009 by Werner Dittmann

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

	* In addition, as a special exception, the copyright holders give
	* permission to link the code of portions of this program with the
	* OpenSSL library under certain conditions as described in each
	* individual source file, and distribute linked combinations
	* including the two.
	* You must obey the GNU General Public License in all respects
	* for all of the code used other than OpenSSL. If you modify
	* file(s) with this exception, you may extend this exception to your
	* version of the file(s), but you are not obligated to do so. If you
	* do not wish to do so, delete this exception statement from your
	* version. If you delete this exception statement from all source
	* files in the program, then also delete it here.
	*/

	/** Copyright (C) 2006, 2009
	*
	* @author Werner Dittmann <Werner.Dittmann@t-online.de>
	*/

	#include <string.h>

	#include <openssl/crypto.h>
	#include <openssl/bio.h>
	#include <openssl/bn.h>
	#include <openssl/rand.h>
	#include <openssl/err.h>
	#include <openssl/dh.h>
	#include <openssl/evp.h>
	#include <openssl/ec.h>
	#include <openssl/ecdh.h>

	#include <zrtp/crypto/zrtpDH.h>
	#include <zrtp/libzrtpcpp/ZrtpTextData.h>

	+#if defined(__APPLE__)
	+# pragma GCC diagnostic push
	+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
	+#endif
	+
	// extern void initializeOpenSSL();

	static BIGNUM* bnP2048 = NULL;
	static BIGNUM* bnP3072 = NULL;
	// static BIGNUM* bnP4096 = NULL;

	static BIGNUM* bnP2048MinusOne = NULL;
	static BIGNUM* bnP3072MinusOne = NULL;
	// static BIGNUM* bnP4096MinusOne = NULL;

	static uint8_t dhinit = 0;

	void randomZRTP(uint8_t *buf, int32_t length)
	{
	// initializeOpenSSL();
	RAND_bytes(buf, length);
	}

	static const uint8_t P2048[] =
	{
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2,
	0x21, 0x68, 0xC2, 0x34, 0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
	0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, 0x02, 0x0B, 0xBE, 0xA6,
	0x3B, 0x13, 0x9B, 0x22, 0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
	0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B, 0x30, 0x2B, 0x0A, 0x6D,
	0xF2, 0x5F, 0x14, 0x37, 0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45,
	0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6, 0xF4, 0x4C, 0x42, 0xE9,
	0xA6, 0x37, 0xED, 0x6B, 0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED,
	0xEE, 0x38, 0x6B, 0xFB, 0x5A, 0x89, 0x9F, 0xA5, 0xAE, 0x9F, 0x24, 0x11,
	0x7C, 0x4B, 0x1F, 0xE6, 0x49, 0x28, 0x66, 0x51, 0xEC, 0xE4, 0x5B, 0x3D,
	0xC2, 0x00, 0x7C, 0xB8, 0xA1, 0x63, 0xBF, 0x05, 0x98, 0xDA, 0x48, 0x36,
	0x1C, 0x55, 0xD3, 0x9A, 0x69, 0x16, 0x3F, 0xA8, 0xFD, 0x24, 0xCF, 0x5F,
	0x83, 0x65, 0x5D, 0x23, 0xDC, 0xA3, 0xAD, 0x96, 0x1C, 0x62, 0xF3, 0x56,
	0x20, 0x85, 0x52, 0xBB, 0x9E, 0xD5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6D,
	0x67, 0x0C, 0x35, 0x4E, 0x4A, 0xBC, 0x98, 0x04, 0xF1, 0x74, 0x6C, 0x08,
	0xCA, 0x18, 0x21, 0x7C, 0x32, 0x90, 0x5E, 0x46, 0x2E, 0x36, 0xCE, 0x3B,
	0xE3, 0x9E, 0x77, 0x2C, 0x18, 0x0E, 0x86, 0x03, 0x9B, 0x27, 0x83, 0xA2,
	0xEC, 0x07, 0xA2, 0x8F, 0xB5, 0xC5, 0x5D, 0xF0, 0x6F, 0x4C, 0x52, 0xC9,
	0xDE, 0x2B, 0xCB, 0xF6, 0x95, 0x58, 0x17, 0x18, 0x39, 0x95, 0x49, 0x7C,
	0xEA, 0x95, 0x6A, 0xE5, 0x15, 0xD2, 0x26, 0x18, 0x98, 0xFA, 0x05, 0x10,
	0x15, 0x72, 0x8E, 0x5A, 0x8A, 0xAC, 0xAA, 0x68, 0xFF, 0xFF, 0xFF, 0xFF,
	0xFF, 0xFF, 0xFF, 0xFF
	};

	static const uint8_t P3072[] =
	{
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2,
	0x21, 0x68, 0xC2, 0x34, 0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
	0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, 0x02, 0x0B, 0xBE, 0xA6,
	0x3B, 0x13, 0x9B, 0x22, 0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
	0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B, 0x30, 0x2B, 0x0A, 0x6D,
	0xF2, 0x5F, 0x14, 0x37, 0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45,
	0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6, 0xF4, 0x4C, 0x42, 0xE9,
	0xA6, 0x37, 0xED, 0x6B, 0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED,
	0xEE, 0x38, 0x6B, 0xFB, 0x5A, 0x89, 0x9F, 0xA5, 0xAE, 0x9F, 0x24, 0x11,
	0x7C, 0x4B, 0x1F, 0xE6, 0x49, 0x28, 0x66, 0x51, 0xEC, 0xE4, 0x5B, 0x3D,
	0xC2, 0x00, 0x7C, 0xB8, 0xA1, 0x63, 0xBF, 0x05, 0x98, 0xDA, 0x48, 0x36,
	0x1C, 0x55, 0xD3, 0x9A, 0x69, 0x16, 0x3F, 0xA8, 0xFD, 0x24, 0xCF, 0x5F,
	0x83, 0x65, 0x5D, 0x23, 0xDC, 0xA3, 0xAD, 0x96, 0x1C, 0x62, 0xF3, 0x56,
	0x20, 0x85, 0x52, 0xBB, 0x9E, 0xD5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6D,
	0x67, 0x0C, 0x35, 0x4E, 0x4A, 0xBC, 0x98, 0x04, 0xF1, 0x74, 0x6C, 0x08,
	0xCA, 0x18, 0x21, 0x7C, 0x32, 0x90, 0x5E, 0x46, 0x2E, 0x36, 0xCE, 0x3B,
	0xE3, 0x9E, 0x77, 0x2C, 0x18, 0x0E, 0x86, 0x03, 0x9B, 0x27, 0x83, 0xA2,
	0xEC, 0x07, 0xA2, 0x8F, 0xB5, 0xC5, 0x5D, 0xF0, 0x6F, 0x4C, 0x52, 0xC9,
	0xDE, 0x2B, 0xCB, 0xF6, 0x95, 0x58, 0x17, 0x18, 0x39, 0x95, 0x49, 0x7C,
	0xEA, 0x95, 0x6A, 0xE5, 0x15, 0xD2, 0x26, 0x18, 0x98, 0xFA, 0x05, 0x10,
	0x15, 0x72, 0x8E, 0x5A, 0x8A, 0xAA, 0xC4, 0x2D, 0xAD, 0x33, 0x17, 0x0D,
	0x04, 0x50, 0x7A, 0x33, 0xA8, 0x55, 0x21, 0xAB, 0xDF, 0x1C, 0xBA, 0x64,
	0xEC, 0xFB, 0x85, 0x04, 0x58, 0xDB, 0xEF, 0x0A, 0x8A, 0xEA, 0x71, 0x57,
	0x5D, 0x06, 0x0C, 0x7D, 0xB3, 0x97, 0x0F, 0x85, 0xA6, 0xE1, 0xE4, 0xC7,
	0xAB, 0xF5, 0xAE, 0x8C, 0xDB, 0x09, 0x33, 0xD7, 0x1E, 0x8C, 0x94, 0xE0,
	0x4A, 0x25, 0x61, 0x9D, 0xCE, 0xE3, 0xD2, 0x26, 0x1A, 0xD2, 0xEE, 0x6B,
	0xF1, 0x2F, 0xFA, 0x06, 0xD9, 0x8A, 0x08, 0x64, 0xD8, 0x76, 0x02, 0x73,
	0x3E, 0xC8, 0x6A, 0x64, 0x52, 0x1F, 0x2B, 0x18, 0x17, 0x7B, 0x20, 0x0C,
	0xBB, 0xE1, 0x17, 0x57, 0x7A, 0x61, 0x5D, 0x6C, 0x77, 0x09, 0x88, 0xC0,
	0xBA, 0xD9, 0x46, 0xE2, 0x08, 0xE2, 0x4F, 0xA0, 0x74, 0xE5, 0xAB, 0x31,
	0x43, 0xDB, 0x5B, 0xFC, 0xE0, 0xFD, 0x10, 0x8E, 0x4B, 0x82, 0xD1, 0x20,
	0xA9, 0x3A, 0xD2, 0xCA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
	};

	/* **************
	static const uint8_t P4096[] =
	{
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2,
	0x21, 0x68, 0xC2, 0x34, 0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
	0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, 0x02, 0x0B, 0xBE, 0xA6,
	0x3B, 0x13, 0x9B, 0x22, 0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
	0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B, 0x30, 0x2B, 0x0A, 0x6D,
	0xF2, 0x5F, 0x14, 0x37, 0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45,
	0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6, 0xF4, 0x4C, 0x42, 0xE9,
	0xA6, 0x37, 0xED, 0x6B, 0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED,
	0xEE, 0x38, 0x6B, 0xFB, 0x5A, 0x89, 0x9F, 0xA5, 0xAE, 0x9F, 0x24, 0x11,
	0x7C, 0x4B, 0x1F, 0xE6, 0x49, 0x28, 0x66, 0x51, 0xEC, 0xE4, 0x5B, 0x3D,
	0xC2, 0x00, 0x7C, 0xB8, 0xA1, 0x63, 0xBF, 0x05, 0x98, 0xDA, 0x48, 0x36,
	0x1C, 0x55, 0xD3, 0x9A, 0x69, 0x16, 0x3F, 0xA8, 0xFD, 0x24, 0xCF, 0x5F,
	0x83, 0x65, 0x5D, 0x23, 0xDC, 0xA3, 0xAD, 0x96, 0x1C, 0x62, 0xF3, 0x56,
	0x20, 0x85, 0x52, 0xBB, 0x9E, 0xD5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6D,
	0x67, 0x0C, 0x35, 0x4E, 0x4A, 0xBC, 0x98, 0x04, 0xF1, 0x74, 0x6C, 0x08,
	0xCA, 0x18, 0x21, 0x7C, 0x32, 0x90, 0x5E, 0x46, 0x2E, 0x36, 0xCE, 0x3B,
	0xE3, 0x9E, 0x77, 0x2C, 0x18, 0x0E, 0x86, 0x03, 0x9B, 0x27, 0x83, 0xA2,
	0xEC, 0x07, 0xA2, 0x8F, 0xB5, 0xC5, 0x5D, 0xF0, 0x6F, 0x4C, 0x52, 0xC9,
	0xDE, 0x2B, 0xCB, 0xF6, 0x95, 0x58, 0x17, 0x18, 0x39, 0x95, 0x49, 0x7C,
	0xEA, 0x95, 0x6A, 0xE5, 0x15, 0xD2, 0x26, 0x18, 0x98, 0xFA, 0x05, 0x10,
	0x15, 0x72, 0x8E, 0x5A, 0x8A, 0xAA, 0xC4, 0x2D, 0xAD, 0x33, 0x17, 0x0D,
	0x04, 0x50, 0x7A, 0x33, 0xA8, 0x55, 0x21, 0xAB, 0xDF, 0x1C, 0xBA, 0x64,
	0xEC, 0xFB, 0x85, 0x04, 0x58, 0xDB, 0xEF, 0x0A, 0x8A, 0xEA, 0x71, 0x57,
	0x5D, 0x06, 0x0C, 0x7D, 0xB3, 0x97, 0x0F, 0x85, 0xA6, 0xE1, 0xE4, 0xC7,
	0xAB, 0xF5, 0xAE, 0x8C, 0xDB, 0x09, 0x33, 0xD7, 0x1E, 0x8C, 0x94, 0xE0,
	0x4A, 0x25, 0x61, 0x9D, 0xCE, 0xE3, 0xD2, 0x26, 0x1A, 0xD2, 0xEE, 0x6B,
	0xF1, 0x2F, 0xFA, 0x06, 0xD9, 0x8A, 0x08, 0x64, 0xD8, 0x76, 0x02, 0x73,
	0x3E, 0xC8, 0x6A, 0x64, 0x52, 0x1F, 0x2B, 0x18, 0x17, 0x7B, 0x20, 0x0C,
	0xBB, 0xE1, 0x17, 0x57, 0x7A, 0x61, 0x5D, 0x6C, 0x77, 0x09, 0x88, 0xC0,
	0xBA, 0xD9, 0x46, 0xE2, 0x08, 0xE2, 0x4F, 0xA0, 0x74, 0xE5, 0xAB, 0x31,
	0x43, 0xDB, 0x5B, 0xFC, 0xE0, 0xFD, 0x10, 0x8E, 0x4B, 0x82, 0xD1, 0x20,
	0xA9, 0x21, 0x08, 0x01, 0x1A, 0x72, 0x3C, 0x12, 0xA7, 0x87, 0xE6, 0xD7,
	0x88, 0x71, 0x9A, 0x10, 0xBD, 0xBA, 0x5B, 0x26, 0x99, 0xC3, 0x27, 0x18,
	0x6A, 0xF4, 0xE2, 0x3C, 0x1A, 0x94, 0x68, 0x34, 0xB6, 0x15, 0x0B, 0xDA,
	0x25, 0x83, 0xE9, 0xCA, 0x2A, 0xD4, 0x4C, 0xE8, 0xDB, 0xBB, 0xC2, 0xDB,
	0x04, 0xDE, 0x8E, 0xF9, 0x2E, 0x8E, 0xFC, 0x14, 0x1F, 0xBE, 0xCA, 0xA6,
	0x28, 0x7C, 0x59, 0x47, 0x4E, 0x6B, 0xC0, 0x5D, 0x99, 0xB2, 0x96, 0x4F,
	0xA0, 0x90, 0xC3, 0xA2, 0x23, 0x3B, 0xA1, 0x86, 0x51, 0x5B, 0xE7, 0xED,
	0x1F, 0x61, 0x29, 0x70, 0xCE, 0xE2, 0xD7, 0xAF, 0xB8, 0x1B, 0xDD, 0x76,
	0x21, 0x70, 0x48, 0x1C, 0xD0, 0x06, 0x91, 0x27, 0xD5, 0xB0, 0x5A, 0xA9,
	0x93, 0xB4, 0xEA, 0x98, 0x8D, 0x8F, 0xDD, 0xC1, 0x86, 0xFF, 0xB7, 0xDC,
	0x90, 0xA6, 0xC0, 0x8F, 0x4D, 0xF4, 0x35, 0xC9, 0x34, 0x06, 0x31, 0x99,
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
	};
	*************** */

	ZrtpDH::ZrtpDH(const char* type) {

	uint8_t random[64];

	// Well - the algo type is only 4 char thus cast to int32 and compare
	if ((int32_t)type == (int32_t)dh2k) {
	pkType = DH2K;
	}
	else if ((int32_t)type == (int32_t)dh3k) {
	pkType = DH3K;
	}
	else if ((int32_t)type == (int32_t)ec25) {
	pkType = EC25;
	}
	else if ((int32_t)type == (int32_t)ec38) {
	pkType = EC38;
	}
	else {
	return;
	}

	// initializeOpenSSL();

	if (!dhinit) {
	bnP2048 = BN_bin2bn(P2048,sizeof(P2048),NULL);
	bnP3072 = BN_bin2bn(P3072,sizeof(P3072),NULL);
	// bnP4096 = BN_bin2bn(P4096,sizeof(P4096),NULL);

	bnP2048MinusOne = BN_dup(bnP2048);
	BN_sub_word(bnP2048MinusOne, 1);

	bnP3072MinusOne = BN_dup(bnP3072);
	BN_sub_word(bnP3072MinusOne, 1);

	// bnP4096MinusOne = BN_dup(bnP4096);
	// BN_sub_word(bnP4096MinusOne, 1);
	dhinit = 1;
	}

	DH* tmpCtx = NULL;
	switch (pkType) {
	case DH2K:
	case DH3K:
	ctx = static_cast<void*>(DH_new());
	tmpCtx = static_cast<DH*>(ctx);
	tmpCtx->g = BN_new();
	BN_set_word(tmpCtx->g, DH_GENERATOR_2);

	if (pkType == DH2K) {
	tmpCtx->p = BN_dup(bnP2048);
	RAND_bytes(random, 32);
	tmpCtx->priv_key = BN_bin2bn(random, 32, NULL);
	}
	else if (pkType == DH3K) {
	tmpCtx->p = BN_dup(bnP3072);
	RAND_bytes(random, 64);
	tmpCtx->priv_key = BN_bin2bn(random, 32, NULL);
	}
	break;

	case EC25:
	ctx = static_cast<void*>(EC_KEY_new_by_curve_name(NID_X9_62_prime256v1));
	break;
	case EC38:
	ctx = static_cast<void*>(EC_KEY_new_by_curve_name(NID_secp384r1));
	break;
	}
	}

	ZrtpDH::~ZrtpDH() {
	if (ctx == NULL)
	return;

	switch (pkType) {
	case DH2K:
	case DH3K:
	DH_free(static_cast<DH*>(ctx));
	break;

	case EC25:
	case EC38:
	EC_KEY_free(static_cast<EC_KEY*>(ctx));
	break;
	}
	}

	int32_t ZrtpDH::computeSecretKey(uint8_t pubKeyBytes, uint8_t secret) {

	if (pkType == DH2K \|\| pkType == DH3K) {
	DH* tmpCtx = static_cast<DH*>(ctx);

	if (tmpCtx->pub_key != NULL) {
	BN_free(tmpCtx->pub_key);
	}
	tmpCtx->pub_key = BN_bin2bn(pubKeyBytes, getDhSize(), NULL);
	return DH_compute_key(secret, tmpCtx->pub_key, tmpCtx);
	}
	if (pkType == EC25 \|\| pkType == EC38) {
	uint8_t buffer[100];
	int32_t ret;
	int32_t len = getPubKeySize();

	buffer[0] = POINT_CONVERSION_UNCOMPRESSED;
	memcpy(buffer+1, pubKeyBytes, len);

	EC_POINT* point = EC_POINT_new(EC_KEY_get0_group(static_cast<EC_KEY*>(ctx)));
	EC_POINT_oct2point(EC_KEY_get0_group(static_cast<EC_KEY*>(ctx)),
	point, buffer, len+1, NULL);
	ret = ECDH_compute_key(secret, getDhSize(), point, static_cast<EC_KEY*>(ctx), NULL);
	EC_POINT_free(point);
	return ret;
	}
	return -1;
	}

	int32_t ZrtpDH::generatePublicKey()
	{
	if (pkType == DH2K \|\| pkType == DH3K)
	return DH_generate_key(static_cast<DH*>(ctx));

	if (pkType == EC25 \|\| pkType == EC38)
	return EC_KEY_generate_key(static_cast<EC_KEY*>(ctx));
	return 0;
	}

	int32_t ZrtpDH::getDhSize() const
	{
	if (pkType == DH2K \|\| pkType == DH3K)
	return DH_size(static_cast<DH*>(ctx));

	if (pkType == EC25)
	return 32;
	if (pkType == EC38)
	return 48;

	return 0;
	}

	int32_t ZrtpDH::getPubKeySize() const
	{
	if (pkType == DH2K \|\| pkType == DH3K)
	return BN_num_bytes(static_cast<DH*>(ctx)->pub_key);

	if (pkType == EC25 \|\| pkType == EC38)
	return EC_POINT_point2oct(EC_KEY_get0_group(static_cast<EC_KEY*>(ctx)),
	EC_KEY_get0_public_key(static_cast<EC_KEY*>(ctx)),
	POINT_CONVERSION_UNCOMPRESSED, NULL, 0, NULL) - 1;
	return 0;

	}

	int32_t ZrtpDH::getPubKeyBytes(uint8_t *buf) const
	{

	if (pkType == DH2K \|\| pkType == DH3K) {
	// get len of pub_key, prepend with zeros to DH size
	int32_t prepend = getDhSize() - getPubKeySize();
	if (prepend > 0) {
	memset(buf, 0, prepend);
	}
	return BN_bn2bin(static_cast<DH*>(ctx)->pub_key, buf + prepend);
	}
	if (pkType == EC25 \|\| pkType == EC38) {
	uint8_t buffer[100];

	int len = EC_POINT_point2oct(EC_KEY_get0_group(static_cast<EC_KEY*>(ctx)),
	EC_KEY_get0_public_key(static_cast<EC_KEY*>(ctx)),
	POINT_CONVERSION_UNCOMPRESSED, buffer, 100, NULL);
	memcpy(buf, buffer+1, len-1);
	return len-1;
	}
	return 0;
	}

	int32_t ZrtpDH::checkPubKey(uint8_t *pubKeyBytes) const
	{
	if (pkType == EC25 \|\| pkType == EC38) {
	uint8_t buffer[100];
	int32_t ret;
	int32_t len = getPubKeySize();

	buffer[0] = POINT_CONVERSION_UNCOMPRESSED;
	memcpy(buffer+1, pubKeyBytes, len);

	EC_POINT* point = EC_POINT_new(EC_KEY_get0_group(static_cast<EC_KEY*>(ctx)));
	EC_POINT_oct2point(EC_KEY_get0_group(static_cast<EC_KEY*>(ctx)),
	point, buffer, len+1, NULL);
	EC_KEY* chkKey = EC_KEY_new();
	EC_KEY_set_group(chkKey, EC_KEY_get0_group(static_cast<EC_KEY*>(ctx)));
	EC_KEY_set_public_key(chkKey, point);
	ret = EC_KEY_check_key(chkKey);

	EC_POINT_free(point);
	EC_KEY_free(chkKey);

	return ret;
	}

	BIGNUM* pubKeyOther = BN_bin2bn(pubKeyBytes, getDhSize(), NULL);

	if (pkType == DH2K) {
	if (BN_cmp(bnP2048MinusOne, pubKeyOther) == 0)
	return 0;
	}
	else if (pkType == DH3K) {
	if (BN_cmp(bnP3072MinusOne, pubKeyOther) == 0)
	return 0;
	}
	else {
	// if (BN_cmp(bnP4096MinusOne, pubKeyOther) == 0)
	return 0;
	}
	int one = BN_is_one(pubKeyOther);
	if (one == 1)
	return 0;

	BN_free(pubKeyOther);
	return 1;
	}

	const char* ZrtpDH::getDHtype()
	{
	switch (pkType) {
	case DH2K:
	return dh2k;
	break;
	case DH3K:
	return dh3k;
	break;
	case EC25:
	return ec25;
	break;
	case EC38:
	return ec38;
	break;
	}
	return NULL;
	}

	+#if defined(__APPLE__)
	+# pragma GCC diagnostic pop
	+#endif
	+
	/ EMACS
	* Local variables:
	* mode: c++
	* c-default-style: ellemtel
	* c-basic-offset: 4
	* End:
	*/

File Metadata

Mime Type: text/x-diff
Expires: Sat, Nov 23, 5:49 AM (1 d, 3 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 3408875
Default Alt Text: (71 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions