summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/Base32.cpp335
-rwxr-xr-xsrc/CMakeLists.txt87
-rw-r--r--src/ZIDFile.cpp430
-rw-r--r--src/ZIDRecord.cpp113
-rw-r--r--src/Zrtp.cpp2527
-rw-r--r--src/ZrtpCWrapper.cpp470
-rw-r--r--src/ZrtpCallbackWrapper.cpp151
-rw-r--r--src/ZrtpConfigure.cpp496
-rw-r--r--src/ZrtpCrc32.cpp223
-rw-r--r--src/ZrtpPacketClearAck.cpp42
-rw-r--r--src/ZrtpPacketCommit.cpp50
-rw-r--r--src/ZrtpPacketConf2Ack.cpp42
-rw-r--r--src/ZrtpPacketConfirm.cpp87
-rw-r--r--src/ZrtpPacketDHPart.cpp98
-rw-r--r--src/ZrtpPacketError.cpp46
-rw-r--r--src/ZrtpPacketErrorAck.cpp42
-rw-r--r--src/ZrtpPacketGoClear.cpp45
-rw-r--r--src/ZrtpPacketHello.cpp129
-rw-r--r--src/ZrtpPacketHelloAck.cpp44
-rw-r--r--src/ZrtpPacketPing.cpp45
-rw-r--r--src/ZrtpPacketPingAck.cpp45
-rw-r--r--src/ZrtpPacketRelayAck.cpp42
-rw-r--r--src/ZrtpPacketSASrelay.cpp75
-rw-r--r--src/ZrtpQueue.cpp847
-rw-r--r--src/ZrtpStateClass.cpp1473
-rw-r--r--src/ZrtpTextData.cpp97
-rw-r--r--src/libzrtpcpp/Base32.h228
-rwxr-xr-xsrc/libzrtpcpp/CMakeLists.txt9
-rw-r--r--src/libzrtpcpp/TimeoutProvider.h303
-rw-r--r--src/libzrtpcpp/ZIDFile.h157
-rw-r--r--src/libzrtpcpp/ZIDRecord.h307
-rw-r--r--src/libzrtpcpp/ZRtp.h1292
-rw-r--r--src/libzrtpcpp/ZrtpCWrapper.h1339
-rw-r--r--src/libzrtpcpp/ZrtpCallback.h367
-rw-r--r--src/libzrtpcpp/ZrtpCallbackWrapper.h101
-rwxr-xr-xsrc/libzrtpcpp/ZrtpCodes.h164
-rw-r--r--src/libzrtpcpp/ZrtpConfigure.h551
-rwxr-xr-xsrc/libzrtpcpp/ZrtpCrc32.h75
-rw-r--r--src/libzrtpcpp/ZrtpPacketBase.h147
-rw-r--r--src/libzrtpcpp/ZrtpPacketClearAck.h54
-rw-r--r--src/libzrtpcpp/ZrtpPacketCommit.h134
-rw-r--r--src/libzrtpcpp/ZrtpPacketConf2Ack.h60
-rw-r--r--src/libzrtpcpp/ZrtpPacketConfirm.h125
-rw-r--r--src/libzrtpcpp/ZrtpPacketDHPart.h120
-rw-r--r--src/libzrtpcpp/ZrtpPacketError.h68
-rw-r--r--src/libzrtpcpp/ZrtpPacketErrorAck.h56
-rw-r--r--src/libzrtpcpp/ZrtpPacketGoClear.h72
-rw-r--r--src/libzrtpcpp/ZrtpPacketHello.h191
-rw-r--r--src/libzrtpcpp/ZrtpPacketHelloAck.h59
-rw-r--r--src/libzrtpcpp/ZrtpPacketPing.h67
-rw-r--r--src/libzrtpcpp/ZrtpPacketPingAck.h74
-rw-r--r--src/libzrtpcpp/ZrtpPacketRelayAck.h56
-rw-r--r--src/libzrtpcpp/ZrtpPacketSASrelay.h113
-rw-r--r--src/libzrtpcpp/ZrtpQueue.h917
-rw-r--r--src/libzrtpcpp/ZrtpStateClass.h324
-rw-r--r--src/libzrtpcpp/ZrtpStates.h90
-rw-r--r--src/libzrtpcpp/ZrtpTextData.h124
-rw-r--r--src/libzrtpcpp/ZrtpUserCallback.h234
-rwxr-xr-xsrc/libzrtpcpp/crypto/TwoCFB.cpp79
-rw-r--r--src/libzrtpcpp/crypto/ZrtpDH.h168
-rw-r--r--src/libzrtpcpp/crypto/aesCFB.h87
-rw-r--r--src/libzrtpcpp/crypto/gcrypt/InitializeGcrypt.cpp130
-rw-r--r--src/libzrtpcpp/crypto/gcrypt/gcryptAesCFB.cpp77
-rw-r--r--src/libzrtpcpp/crypto/gcrypt/gcryptZrtpDH.cpp349
-rw-r--r--src/libzrtpcpp/crypto/gcrypt/gcrypthmac256.cpp68
-rw-r--r--src/libzrtpcpp/crypto/gcrypt/gcrypthmac384.cpp68
-rw-r--r--src/libzrtpcpp/crypto/gcrypt/gcryptsha256.cpp89
-rw-r--r--src/libzrtpcpp/crypto/gcrypt/gcryptsha384.cpp89
-rw-r--r--src/libzrtpcpp/crypto/hmac256.h96
-rw-r--r--src/libzrtpcpp/crypto/hmac384.h96
-rw-r--r--src/libzrtpcpp/crypto/openssl/AesCFB.cpp89
-rwxr-xr-xsrc/libzrtpcpp/crypto/openssl/InitializeOpenSSL.cpp242
-rw-r--r--src/libzrtpcpp/crypto/openssl/ZrtpDH.cpp426
-rw-r--r--src/libzrtpcpp/crypto/openssl/hmac256.cpp67
-rw-r--r--src/libzrtpcpp/crypto/openssl/hmac384.cpp67
-rw-r--r--src/libzrtpcpp/crypto/openssl/sha256.cpp97
-rw-r--r--src/libzrtpcpp/crypto/openssl/sha384.cpp97
-rw-r--r--src/libzrtpcpp/crypto/sha256.h144
-rw-r--r--src/libzrtpcpp/crypto/sha384.h144
-rwxr-xr-xsrc/libzrtpcpp/crypto/twoCFB.h87
-rw-r--r--src/libzrtpcpp/crypto/twofish.c1733
-rwxr-xr-xsrc/libzrtpcpp/crypto/twofish.h265
-rwxr-xr-xsrc/libzrtpcpp/crypto/twofish_cfb.c82
-rw-r--r--src/libzrtpcpp/zrtpPacket.h342
-rw-r--r--src/libzrtpcpp/zrtpccrtp.h76
85 files changed, 21413 insertions, 0 deletions
diff --git a/src/Base32.cpp b/src/Base32.cpp
new file mode 100644
index 0000000..ccc8034
--- /dev/null
+++ b/src/Base32.cpp
@@ -0,0 +1,335 @@
+/**
+ *
+ * Copyright (c) 2002 Bryce "Zooko" Wilcox-O'Hearn Permission is hereby
+ * granted, free of charge, to any person obtaining a copy of this software to
+ * deal in this software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of this software, and to permit persons to whom this software
+ * is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of this software.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THIS SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THIS SOFTWARE.
+ *
+ * Converted to C++ by:
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+#ifndef UNIT_TEST
+#include <libzrtpcpp/Base32.h>
+#else
+#include "libzrtpcpp/Base32.h"
+#endif
+
+int divceil(int a, int b) {
+ int c;
+ if (a>0) {
+ if (b>0) c=a+b-1;
+ else c=a;
+ } else {
+ if (b>0) c=a;
+ else c=a+b+1;
+ }
+ return c/b;
+}
+
+// 1 2 3
+// 01234567890123456789012345678901
+static const char* const chars= "ybndrfg8ejkmcpqxot1uwisza345h769";
+
+/*
+ * revchars: index into this table with the ASCII value of the char.
+ * The result is the value of that quintet.
+ */
+static const unsigned char revchars[]= {
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 18, 255, 25, 26, 27, 30, 29,
+ 7, 31, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 24, 1, 12, 3, 8, 5, 6,
+ 28, 21, 9, 10, 255, 11, 2, 16,
+ 13, 14, 4, 22, 17, 19, 255, 20,
+ 15, 0, 23, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255
+};
+
+
+Base32::Base32(const string encoded):
+ binaryResult(NULL), resultLength(0) {
+
+ a2b_l(encoded, encoded.size(), (encoded.size()*5/8)*8);
+}
+
+Base32::Base32(const string encoded, int noOfBits):
+ binaryResult(NULL), resultLength(0) {
+
+ a2b_l(encoded, divceil(noOfBits, 5), noOfBits);
+}
+
+Base32::Base32(const unsigned char* data, int noOfBits):
+ binaryResult(NULL), resultLength(0) {
+
+ b2a_l(data, (noOfBits+7)/8, noOfBits);
+}
+
+Base32::~Base32() {
+ if (binaryResult != NULL && binaryResult != smallBuffer) {
+ delete [] binaryResult;
+ }
+ binaryResult = NULL;
+}
+
+const unsigned char* Base32::getDecoded(int &length) {
+ length = resultLength;
+ return binaryResult;
+}
+
+void Base32::b2a_l(const unsigned char* os, int len,
+ const size_t lengthinbits) {
+
+ /* if lengthinbits is not a multiple of 8 then this is allocating
+ * space for 0, 1, or 2 extra quintets that will be truncated at the
+ * end of this function if they are not needed
+ */
+ string result(divceil(len*8, 5), ' ');
+
+ /* index into the result buffer, initially pointing to the
+ * "one-past-the-end" quintet
+ */
+ int resp = result.size();
+
+ /* pointer into the os buffer, initially pointing to the
+ * "one-past-the-end" octet
+ */
+ const unsigned char* osp = os + len;
+
+ /* Now this is a real live Duff's device. You gotta love it. */
+
+ unsigned long x = 0; // to hold up to 32 bits worth of the input
+ switch ((osp - os) % 5) {
+
+ case 0:
+ do {
+ x = *--osp;
+ result[--resp] = chars[x % 32]; /* The least sig 5 bits go into the final quintet. */
+ x /= 32; /* ... now we have 3 bits worth in x... */
+ case 4:
+ x |= ((unsigned long)(*--osp)) << 3; /* ... now we have 11 bits worth in x... */
+ result[--resp] = chars[x % 32];
+ x /= 32; /* ... now we have 6 bits worth in x... */
+ result[--resp] = chars[x % 32];
+ x /= 32; /* ... now we have 1 bits worth in x... */
+ case 3:
+ x |= ((unsigned long)(*--osp)) << 1; /* The 8 bits from the 2-indexed octet.
+ So now we have 9 bits worth in x... */
+ result[--resp] = chars[x % 32];
+ x /= 32; /* ... now we have 4 bits worth in x... */
+ case 2:
+ x |= ((unsigned long)(*--osp)) << 4; /* The 8 bits from the 1-indexed octet.
+ So now we have 12 bits worth in x... */
+ result[--resp] = chars[x%32];
+ x /= 32; /* ... now we have 7 bits worth in x... */
+ result[--resp] = chars[x%32];
+ x /= 32; /* ... now we have 2 bits worth in x... */
+ case 1:
+ x |= ((unsigned long)(*--osp)) << 2; /* The 8 bits from the 0-indexed octet.
+ So now we have 10 bits worth in x... */
+ result[--resp] = chars[x%32];
+ x /= 32; /* ... now we have 5 bits worth in x... */
+ result[--resp] = chars[x];
+ } while (osp > os);
+ } /* switch ((osp - os.buf) % 5) */
+
+ /* truncate any unused trailing zero quintets */
+ encoded = result.substr(0, divceil(lengthinbits, 5));
+ return;
+}
+
+void Base32::a2b_l(const string cs, size_t size, const size_t lengthinbits ) {
+ unsigned long x = 0; // to hold up to 32 bits worth of the input
+
+ int len = divceil(size*5, 8);
+
+ /* if lengthinbits is not a multiple of 5 then this is
+ * allocating space for 0 or 1 extra octets that will be
+ * truncated at the end of this function if they are
+ * not needed
+ */
+
+ if (len < 128) {
+ binaryResult = smallBuffer;
+ }
+ else {
+ binaryResult = new unsigned char[len];
+ }
+
+ /* pointer into the result buffer, initially pointing to
+ * the "one-past-the-end" octet
+ */
+ unsigned char* resp = binaryResult + len;
+
+ /* index into the input buffer, initially pointing to the
+ * "one-past-the-end" character
+ */
+ int csp = size;
+
+ /* Now this is a real live Duff's device. You gotta love it. */
+ switch (csp % 8) {
+ case 0:
+ do {
+ x = revchars[cs[--csp]&0xff]; /* 5 bits... */
+ case 7:
+ x |= revchars[cs[--csp]&0xff] << 5; /* 10 bits... */
+ *--resp = x % 256;
+ x /= 256; /* 2 bits... */
+ case 6:
+ x |= revchars[cs[--csp]&0xff] << 2; /* 7 bits... */
+ case 5:
+ x |= revchars[cs[--csp]&0xff] << 7; /* 12 bits... */
+ *--resp = x % 256;
+ x /= 256; /* 4 bits... */
+ case 4:
+ x |= revchars[cs[--csp]&0xff] << 4; /* 9 bits... */
+ *--resp = x % 256;
+ x /= 256; /* 1 bit... */
+ case 3:
+ x |= revchars[cs[--csp]&0xff] << 1; /* 6 bits... */
+ case 2:
+ x |= revchars[cs[--csp]&0xff] << 6; /* 11 bits... */
+ *--resp = x % 256;
+ x /= 256; /* 3 bits... */
+ case 1:
+ x |= revchars[cs[--csp]&0xff] << 3; /* 8 bits... */
+ *--resp = x % 256;
+ } while (csp);
+ } /* switch ((csp - cs.buf) % 8) */
+
+ /* truncate any unused trailing zero octets */
+ resultLength = divceil(lengthinbits, 8);
+ return;
+}
+
+#ifdef UNIT_TEST
+#include <math.h>
+
+
+static uint8_t *randz(const size_t len)
+{
+ uint8_t* result = (uint8_t*)malloc(len);
+ size_t i;
+ for (i=0; i<len; i++) {
+ result[i] = rand() % 256;
+ }
+ return result;
+}
+
+int main(int argc, char *argv[]) {
+
+ int32_t resLen;
+ string a;
+ const uint8_t* zrecovered;
+ uint8_t ones[] = {1, 1, 1, 1, 1};
+ uint8_t zrtpVec01[] = {0x00, 0x00, 0x00, 0x00};
+ uint8_t zrtpVec02[] = {0x80, 0x00, 0x00, 0x00};
+ uint8_t zrtpVec03[] = {0x40, 0x00, 0x00, 0x00};
+ uint8_t zrtpVec04[] = {0xc0, 0x00, 0x00, 0x00};
+ uint8_t zrtpVec05[] = {0x00, 0x00, 0x00, 0x00};
+ uint8_t zrtpVec06[] = {0x80, 0x80, 0x00, 0x00};
+ uint8_t zrtpVec07[] = {0x8b, 0x88, 0x80, 0x00};
+ uint8_t zrtpVec08[] = {0xf0, 0xbf, 0xc7, 0x00};
+ uint8_t zrtpVec09[] = {0xd4, 0x7a, 0x04, 0x00};
+ uint8_t zrtpVec10[] = {0xf5, 0x57, 0xbb, 0x0c};
+
+ // Encode all bits of the 5 one bytes (= 40 bits)
+ a = Base32(ones, 5*8).getEncoded();
+
+ // The string should be: "yryonyeb"
+ cout << "Encoded 5 ones: '" << a << "', Expected: 'yryonyeb'" << endl;
+
+ // Now decode all bits and check
+ Base32 *y = new Base32(a);
+ zrecovered = y->getDecoded(resLen);
+ if (resLen != 5 && memcmp(ones, zrecovered, 5)) {
+ printf("Failed basic 5 ones recovery test.\n");
+ return -1;
+ }
+ delete y;
+
+ a = Base32(ones, 15).getEncoded();
+ cout << "Encoded 5 ones, 15 bits only: '" << a << "', Expected: 'yry'" << endl;
+ // now decode 15 bits (out of 40 possible)
+ y = new Base32(a, 15);
+ zrecovered = y->getDecoded(resLen);
+ printf("Decoded 15 bits, result length: %d (should be 2)\n", resLen);
+ printf("Decoded bytes: %x %x (should be 1 0)\n", zrecovered[0], zrecovered[1]);
+ delete y;
+
+ // Encode 20 bits of the test vectors
+ a = Base32(zrtpVec01, 20).getEncoded();
+ cout << "Encoded ZRTP vector 01: '" << a << "', Expected: 'yyyy'" << endl;
+ a = Base32(zrtpVec02, 20).getEncoded();
+ cout << "Encoded ZRTP vector 02: '" << a << "', Expected: 'oyyy'" << endl;
+ a = Base32(zrtpVec03, 20).getEncoded();
+ cout << "Encoded ZRTP vector 02: '" << a << "', Expected: 'eyyy'" << endl;
+ a = Base32(zrtpVec04, 20).getEncoded();
+ cout << "Encoded ZRTP vector 04: '" << a << "', Expected: 'ayyy'" << endl;
+ a = Base32(zrtpVec05, 20).getEncoded();
+ cout << "Encoded ZRTP vector 05: '" << a << "', Expected: 'yyyy'" << endl;
+ a = Base32(zrtpVec06, 20).getEncoded();
+ cout << "Encoded ZRTP vector 06: '" << a << "', Expected: 'onyy'" << endl;
+ a = Base32(zrtpVec07, 20).getEncoded();
+ cout << "Encoded ZRTP vector 07: '" << a << "', Expected: 'tqre'" << endl;
+ a = Base32(zrtpVec08, 20).getEncoded();
+ cout << "Encoded ZRTP vector 08: '" << a << "', Expected: '6n9h'" << endl;
+ a = Base32(zrtpVec09, 20).getEncoded();
+ cout << "Encoded ZRTP vector 09: '" << a << "', Expected: '4t7y'" << endl;
+ a = Base32(zrtpVec10, 20).getEncoded();
+ cout << "Encoded ZRTP vector 10: '" << a << "', Expected: '6im5'" << endl;
+
+ // test the 30 bit output of same data as 20 bit
+ a = Base32(zrtpVec10, 30).getEncoded();
+ cout << "Encoded ZRTP vector 10 (30bit): '" << a << "', Expected: '6im5sd'" << endl;
+
+ for (int i = 0; i < 2; i++) {
+ uint8_t* z = randz(16);
+ a = Base32(z, 16*8).getEncoded();
+// cout << "Result: " << a << endl;
+ assert (a.size() == Base32::b2alen(16*8));
+ zrecovered = Base32(a).getDecoded(resLen);
+ if (resLen != 16 && memcmp(z, zrecovered, 16)) {
+ printf("Failed basic recovery test.\n");
+ return -1;
+ }
+ free((void*)z);
+ }
+}
+#endif
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
new file mode 100755
index 0000000..4febbde
--- /dev/null
+++ b/src/CMakeLists.txt
@@ -0,0 +1,87 @@
+cmake_minimum_required (VERSION 2.6)
+
+# add_subdirectory(libzrtpcpp)
+# add_subdirectory(libzrtpcpp/crypto)
+
+include_directories (${CMAKE_CURRENT_SOURCE_DIR})
+
+set(gcrypt_src
+ libzrtpcpp/crypto/gcrypt/gcryptZrtpDH.cpp
+ libzrtpcpp/crypto/gcrypt/gcrypthmac256.cpp
+ libzrtpcpp/crypto/gcrypt/gcryptsha256.cpp
+ libzrtpcpp/crypto/gcrypt/gcrypthmac384.cpp
+ libzrtpcpp/crypto/gcrypt/gcryptsha384.cpp
+ libzrtpcpp/crypto/gcrypt/gcryptAesCFB.cpp
+ libzrtpcpp/crypto/gcrypt/InitializeGcrypt.cpp)
+
+set(openssl_src
+ libzrtpcpp/crypto/openssl/ZrtpDH.cpp
+ libzrtpcpp/crypto/openssl/hmac256.cpp
+ libzrtpcpp/crypto/openssl/sha256.cpp
+ libzrtpcpp/crypto/openssl/hmac384.cpp
+ libzrtpcpp/crypto/openssl/sha384.cpp
+ libzrtpcpp/crypto/openssl/AesCFB.cpp
+ libzrtpcpp/crypto/openssl/InitializeOpenSSL.cpp)
+
+if (GCRYPT_FOUND)
+ set(crypto_src ${gcrypt_src})
+endif()
+
+if (OPENSSL_FOUND AND HAVE_OPENSSL_EC_H)
+ set(crypto_src ${openssl_src})
+endif()
+
+if(enable_ccrtp)
+ set(ccrtp_src ZrtpQueue.cpp)
+endif()
+
+set(twofish_srcs libzrtpcpp/crypto/twofish.c
+ libzrtpcpp/crypto/twofish_cfb.c
+ libzrtpcpp/crypto/TwoCFB.cpp)
+
+set(zrtp_src
+ ZrtpCallbackWrapper.cpp
+ ZIDFile.cpp
+ ZIDRecord.cpp
+ Zrtp.cpp
+ ZrtpCrc32.cpp
+ ZrtpPacketCommit.cpp
+ ZrtpPacketConf2Ack.cpp
+ ZrtpPacketConfirm.cpp
+ ZrtpPacketDHPart.cpp
+ ZrtpPacketGoClear.cpp
+ ZrtpPacketClearAck.cpp
+ ZrtpPacketHelloAck.cpp
+ ZrtpPacketHello.cpp
+ ZrtpPacketError.cpp
+ ZrtpPacketErrorAck.cpp
+ ZrtpPacketPingAck.cpp
+ ZrtpPacketPing.cpp
+ ZrtpPacketSASrelay.cpp
+ ZrtpPacketRelayAck.cpp
+ ZrtpStateClass.cpp
+ ZrtpTextData.cpp
+ ZrtpConfigure.cpp
+ ZrtpCWrapper.cpp
+ Base32.cpp)
+
+set(zrtpcpp_src ${zrtp_src} ${ccrtp_src} ${crypto_src} ${twofish_srcs})
+
+if(BUILD_STATIC AND NOT BUILD_SHARED)
+ set(LIBRARY_BUILD_TYPE STATIC)
+else()
+ set(LIBRARY_BUILD_TYPE SHARED)
+endif()
+
+add_library(${zrtplib} ${LIBRARY_BUILD_TYPE} ${zrtpcpp_src})
+set_target_properties(${zrtplib} PROPERTIES VERSION ${VERSION} SOVERSION ${SOVERSION})
+target_link_libraries(${zrtplib} ${LIBS})
+
+if(enable_ccrtp)
+ add_dependencies(${zrtplib} ccrtp)
+endif()
+
+add_subdirectory(libzrtpcpp)
+
+install(TARGETS ${zrtplib} DESTINATION ${LIBDIRNAME})
+
diff --git a/src/ZIDFile.cpp b/src/ZIDFile.cpp
new file mode 100644
index 0000000..69b43eb
--- /dev/null
+++ b/src/ZIDFile.cpp
@@ -0,0 +1,430 @@
+/*
+ Copyright (C) 2006-2008 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+// #define UNIT_TEST
+
+#include <string>
+#include <time.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <libzrtpcpp/ZIDFile.h>
+
+
+static ZIDFile* instance;
+static int errors = 0; // maybe we will use as member of ZIDFile later...
+
+void ZIDFile::createZIDFile(char* name) {
+ zidFile = fopen(name, "wb+");
+ // New file, generate an associated random ZID and save
+ // it as first record
+ if (zidFile != NULL) {
+ unsigned int* ip;
+ ip = (unsigned int*) associatedZid;
+ srand(time(NULL));
+ *ip++ = rand();
+ *ip++ = rand();
+ *ip = rand();
+
+ ZIDRecord rec(associatedZid);
+ rec.setOwnZIDRecord();
+ fseek(zidFile, 0L, SEEK_SET);
+ if (fwrite(rec.getRecordData(), rec.getRecordLength(), 1, zidFile) < 1)
+ ++errors;
+ fflush(zidFile);
+ }
+}
+
+/**
+ * Migrate old ZID file format to new one.
+ *
+ * If ZID file is old format:
+ * - close it, rename it, then re-open
+ * - create ZID file for new format
+ * - copy over contents and flags.
+ */
+void ZIDFile::checkDoMigration(char* name) {
+ FILE* fdOld;
+ unsigned char inb[2];
+ zidrecord1_t recOld;
+
+ fseek(zidFile, 0L, SEEK_SET);
+ if (fread(inb, 2, 1, zidFile) < 1) {
+ ++errors;
+ inb[0] = 0;
+ }
+
+ if (inb[0] > 0) { // if it's new format just return
+ return;
+ }
+ fclose(zidFile); // close old ZID file
+ zidFile = NULL;
+
+ // create save file name, rename and re-open
+ // if rename fails, just unlink old ZID file and create a brand new file
+ // just a little inconvenience for the user, need to verify new SAS
+ std::string fn = std::string(name) + std::string(".save");
+ if (rename(name, fn.c_str()) < 0) {
+ unlink(name);
+ createZIDFile(name);
+ return;
+ }
+ fdOld = fopen(fn.c_str(), "rb"); // reopen old format in read only mode
+
+ // Get first record from old file - is the own ZID
+ fseek(fdOld, 0L, SEEK_SET);
+ if (fread(&recOld, sizeof(zidrecord1_t), 1, fdOld) != 1) {
+ fclose(fdOld);
+ return;
+ }
+ if (recOld.ownZid != 1) {
+ fclose(fdOld);
+ return;
+ }
+ zidFile = fopen(name, "wb+"); // create new format file in binary r/w mode
+ if (zidFile == NULL) {
+ return;
+ }
+ // create ZIDRecord in new format, copy over own ZID and write the record
+ ZIDRecord rec(recOld.identifier);
+ rec.setOwnZIDRecord();
+ if (fwrite(rec.getRecordData(), rec.getRecordLength(), 1, zidFile) < 1)
+ ++errors;
+
+ // now copy over all valid records from old ZID file format.
+ // Sequentially read old records, sequentially write new records
+ int numRead;
+ do {
+ numRead = fread(&recOld, sizeof(zidrecord1_t), 1, fdOld);
+ if (numRead == 0) { // all old records processed
+ break;
+ }
+ // skip own ZID record and invalid records
+ if (recOld.ownZid == 1 || recOld.recValid == 0) {
+ continue;
+ }
+ ZIDRecord rec2(recOld.identifier);
+ rec2.setValid();
+ if (recOld.rs1Valid & SASVerified) {
+ rec2.setSasVerified();
+ }
+ rec2.setNewRs1(recOld.rs2Data);
+ rec2.setNewRs1(recOld.rs1Data);
+ if (fwrite(rec2.getRecordData(), rec2.getRecordLength(), 1, zidFile) < 1)
+ ++errors;
+
+ } while (numRead == 1);
+ fflush(zidFile);
+}
+
+ZIDFile::~ZIDFile() {
+ close();
+}
+
+ZIDFile* ZIDFile::getInstance() {
+
+ if (instance == NULL) {
+ instance = new ZIDFile();
+ }
+ return instance;
+}
+
+int ZIDFile::open(char* name) {
+
+ // check for an already active ZID file
+ if (zidFile != NULL) {
+ return 0;
+ }
+ if ((zidFile = fopen(name, "rb+")) == NULL) {
+ createZIDFile(name);
+ } else {
+ checkDoMigration(name);
+ if (zidFile != NULL) {
+ ZIDRecord rec;
+ fseek(zidFile, 0L, SEEK_SET);
+ if (fread(rec.getRecordData(), rec.getRecordLength(), 1, zidFile) != 1) {
+ fclose(zidFile);
+ zidFile = NULL;
+ return -1;
+ }
+ if (!rec.isOwnZIDRecord()) {
+ fclose(zidFile);
+ zidFile = NULL;
+ return -1;
+ }
+ memcpy(associatedZid, rec.getIdentifier(), IDENTIFIER_LEN);
+ }
+ }
+ return ((zidFile == NULL) ? -1 : 1);
+}
+
+void ZIDFile::close() {
+
+ if (zidFile != NULL) {
+ fclose(zidFile);
+ zidFile = NULL;
+ }
+}
+
+unsigned int ZIDFile::getRecord(ZIDRecord* zidRecord) {
+ unsigned long pos;
+ ZIDRecord rec;
+ int numRead;
+
+ // set read pointer behind first record (
+ fseek(zidFile, rec.getRecordLength(), SEEK_SET);
+
+ do {
+ pos = ftell(zidFile);
+ numRead = fread(rec.getRecordData(), rec.getRecordLength(), 1, zidFile);
+ if (numRead == 0) {
+ break;
+ }
+
+ // skip own ZID record and invalid records
+ if (rec.isOwnZIDRecord() || !rec.isValid()) {
+ continue;
+ }
+
+ } while (numRead == 1 &&
+ memcmp(zidRecord->getIdentifier(), rec.getIdentifier(), IDENTIFIER_LEN) != 0);
+
+ // If we reached end of file, then no record with the ZID
+ // found. We need to create a new ZID record.
+ if (numRead == 0) {
+ // create new record
+ ZIDRecord rec1(zidRecord->getIdentifier());
+ rec1.setValid();
+ if (fwrite(rec1.getRecordData(), rec1.getRecordLength(), 1, zidFile) < 1)
+ ++errors;
+ memcpy(zidRecord->getRecordData(), rec1.getRecordData(), rec1.getRecordLength());
+ } else {
+ // Copy the read data into caller's the record storage
+ memcpy(zidRecord->getRecordData(), rec.getRecordData(), rec.getRecordLength());
+ }
+
+ // remember position of record in file for save operation
+ zidRecord->setPosition(pos);
+ return 1;
+}
+
+unsigned int ZIDFile::saveRecord(ZIDRecord *zidRecord) {
+
+ fseek(zidFile, zidRecord->getPosition(), SEEK_SET);
+ if (fwrite(zidRecord->getRecordData(), zidRecord->getRecordLength(), 1, zidFile) < 1)
+ ++errors;
+ fflush(zidFile);
+ return 1;
+}
+
+
+#ifdef UNIT_TEST
+
+#include <iostream>
+#include <unistd.h>
+using namespace std;
+
+static void hexdump(const char* title, const unsigned char *s, int l) {
+ int n=0;
+
+ if (s == NULL) return;
+
+ fprintf(stderr, "%s",title);
+ for (; n < l ; ++n) {
+ if ((n%16) == 0)
+ fprintf(stderr, "\n%04x",n);
+ fprintf(stderr, " %02x",s[n]);
+ }
+ fprintf(stderr, "\n");
+}
+
+int main(int argc, char *argv[]) {
+
+ unsigned char myId[IDENTIFIER_LEN];
+ ZIDFile *zid = ZIDFile::getInstance();
+
+ unlink("testzid2");
+ zid->open("testzid2");
+ hexdump("My ZID: ", zid->getZid(), IDENTIFIER_LEN);
+ memcpy(myId, zid->getZid(), IDENTIFIER_LEN);
+ zid->close();
+
+ zid->open("testzid2");
+ if (memcmp(myId, zid->getZid(), IDENTIFIER_LEN) != 0) {
+ cerr << "Wrong ZID in testfile" << endl;
+ return 1;
+ }
+
+ // Create a new ZID record for peer ZID "123456789012"
+ ZIDRecord zr3((unsigned char*) "123456789012");
+ zid->getRecord(&zr3);
+ if (!zr3.isValid()) {
+ cerr << "New ZID record '123456789012' not set to valid" << endl;
+ return 1;
+ }
+ zid->saveRecord(&zr3);
+
+ // create a second record with peer ZID "210987654321"
+ ZIDRecord zr4((unsigned char*) "210987654321");
+ zid->getRecord(&zr4);
+ if (!zr4.isValid()) {
+ cerr << "New ZID record '210987654321' not set to valid" << endl;
+ return 1;
+ }
+ zid->saveRecord(&zr4);
+
+ // now set a first RS1 with default expiration interval, check
+ // if set correctly, valid flag and expiration interval
+ zr3.setNewRs1((unsigned char*) "11122233344455566677788899900012");
+ if (memcmp(zr3.getRs1(), "11122233344455566677788899900012", RS_LENGTH) != 0) {
+ cerr << "RS1 was not set (111...012)" << endl;
+ return 1;
+ }
+ if (!zr3.isRs1Valid()) {
+ cerr << "RS1 was not set to valid state (111...012)" << endl;
+ return 1;
+ }
+ if (!zr3.isRs1NotExpired()) {
+ cerr << "RS1 expired (111...012)" << endl;
+ return 1;
+ }
+ if (zr3.isRs2Valid()) {
+ cerr << "RS2 was set to valid state (111...012)" << endl;
+ return 1;
+ }
+ zid->saveRecord(&zr3);
+
+ // create a second RS1, RS2 will become the first RS1, check
+ // if set correctly, valid flag and expiration interval for both
+ // RS1 and RS2
+ zr3.setNewRs1((unsigned char*) "00099988877766655544433322211121");
+ if (memcmp(zr3.getRs1(), "00099988877766655544433322211121", RS_LENGTH) != 0) {
+ cerr << "RS1 was not set (000...121)" << endl;
+ return 1;
+ }
+ if (!zr3.isRs1Valid()) {
+ cerr << "RS1 was not set to valid state (000...121)" << endl;
+ return 1;
+ }
+ if (!zr3.isRs1NotExpired()) {
+ cerr << "RS1 expired (000...121)" << endl;
+ return 1;
+ }
+ if (memcmp(zr3.getRs2(), "11122233344455566677788899900012", RS_LENGTH) != 0) {
+ cerr << "RS2 was not set (111...012)" << endl;
+ return 1;
+ }
+ if (!zr3.isRs2Valid()) {
+ cerr << "RS2 was not set to valid state (111...012)" << endl;
+ return 1;
+ }
+ if (!zr3.isRs2NotExpired()) {
+ cerr << "RS2 expired (111...012)" << endl;
+ return 1;
+ }
+ zid->saveRecord(&zr3);
+
+ zid->close();
+
+ // Reopen, check if first record is still valid, RSx vaild and
+ // not expired. Then manipulate 2nd record.
+ zid->open("testzid2");
+
+ ZIDRecord zr3a((unsigned char*) "123456789012");
+ zid->getRecord(&zr3a);
+ if (!zr3a.isValid()) {
+ cerr << "Re-read ZID record '123456789012' not set to valid" << endl;
+ return 1;
+ }
+ if (memcmp(zr3a.getRs1(), "00099988877766655544433322211121", RS_LENGTH) != 0) {
+ cerr << "re-read RS1 was not set (000...121)" << endl;
+ return 1;
+ }
+ if (!zr3a.isRs1Valid()) {
+ cerr << "Re-read RS1 was not set to valid state (000...121)" << endl;
+ return 1;
+ }
+ if (!zr3a.isRs1NotExpired()) {
+ cerr << "re-read RS1 expired (000...121)" << endl;
+ return 1;
+ }
+ if (memcmp(zr3a.getRs2(), "11122233344455566677788899900012", RS_LENGTH) != 0) {
+ cerr << "re-read RS2 was not set (111...012)" << endl;
+ return 1;
+ }
+ if (!zr3a.isRs2Valid()) {
+ cerr << "Re-read RS2 was not set to valid state (111...012)" << endl;
+ return 1;
+ }
+ if (!zr3a.isRs2NotExpired()) {
+ cerr << "Re-read RS2 expired (111...012)" << endl;
+ return 1;
+ }
+
+ ZIDRecord zr5((unsigned char*) "210987654321");
+ zid->getRecord(&zr5);
+
+
+ // set new RS1 with expire interval of 5 second, then check immediatly
+ zr5.setNewRs1((unsigned char*) "aaa22233344455566677788899900012", 5);
+ if (!zr5.isValid()) {
+ cerr << "Re-read ZID record '210987654321' not set to valid" << endl;
+ return 1;
+ }
+ if (memcmp(zr5.getRs1(), "aaa22233344455566677788899900012", RS_LENGTH) != 0) {
+ cerr << "RS1 (2) was not set (aaa...012)" << endl;
+ return 1;
+ }
+ if (!zr5.isRs1Valid()) {
+ cerr << "RS1 (2) was not set to valid state (aaa...012)" << endl;
+ return 1;
+ }
+ if (!zr5.isRs1NotExpired()) {
+ cerr << "RS1 (2) expired (aaa...012)" << endl;
+ return 1;
+ }
+
+ // wait for 6 second, now the expire check shall fail
+ sleep(6);
+ if (zr5.isRs1NotExpired()) {
+ cerr << "RS1 (2) is not expired after defined interval (aaa...012)" << endl;
+ return 1;
+ }
+
+ zr5.setNewRs1((unsigned char*) "bbb99988877766655544433322211121", 256);
+ zid->saveRecord(&zr5);
+
+ zid->close();
+
+ // Test migration
+ zid->open("testzidOld");
+ zid->close();
+
+}
+
+#endif
+
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-default-style: ellemtel
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/src/ZIDRecord.cpp b/src/ZIDRecord.cpp
new file mode 100644
index 0000000..d62c2e3
--- /dev/null
+++ b/src/ZIDRecord.cpp
@@ -0,0 +1,113 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <time.h>
+
+#include <libzrtpcpp/ZIDRecord.h>
+
+void ZIDRecord::setNewRs1(const unsigned char* data, int32_t expire) {
+
+ // shift RS1 data into RS2 position
+ memcpy(record.rs2Data, record.rs1Data, RS_LENGTH);
+ memcpy(record.rs2Interval, record.rs1Interval, TIME_LENGTH);
+
+ // now propagate flags as well
+ if (isRs1Valid()) {
+ setRs2Valid();
+ }
+
+ // set new RS1 data
+ memcpy(record.rs1Data, data, RS_LENGTH);
+
+ time_t validThru;
+ if (expire == -1) {
+ validThru = -1;
+ }
+ else if (expire <= 0) {
+ validThru = 0;
+ }
+ else {
+ validThru = time(NULL) + expire;
+ }
+
+ if (sizeof(time_t) == 4) {
+ long long temp = validThru;
+ memcpy(record.rs1Interval, (unsigned char*)&temp, TIME_LENGTH);
+ }
+ else {
+ memcpy(record.rs1Interval, (unsigned char*)&validThru, TIME_LENGTH);
+ }
+ setRs1Valid();
+}
+
+
+const bool ZIDRecord::isRs1NotExpired() {
+ time_t current = time(NULL);
+ time_t validThru;
+
+ if (sizeof(time_t) == 4) {
+ long long temp;
+ memcpy((unsigned char*)&temp, record.rs1Interval, TIME_LENGTH);
+ validThru = temp;
+ }
+ else {
+ memcpy((unsigned char*)&validThru, record.rs1Interval, TIME_LENGTH);
+ }
+
+ if (validThru == -1)
+ return true;
+ if (validThru == 0)
+ return false;
+ return (current <= validThru) ? true : false;
+}
+
+const bool ZIDRecord::isRs2NotExpired() {
+ time_t current = time(NULL);
+ time_t validThru;
+
+ if (sizeof(time_t) == 4) {
+ long long temp;
+ memcpy((unsigned char*)&temp, record.rs2Interval, TIME_LENGTH);
+ validThru = temp;
+ }
+ else {
+ memcpy((unsigned char*)&validThru, record.rs2Interval, TIME_LENGTH);
+ }
+
+ if (validThru == -1)
+ return true;
+ if (validThru == 0)
+ return false;
+ return (current <= validThru) ? true : false;
+}
+
+void ZIDRecord::setMiTMData(const unsigned char* data) {
+ memcpy(record.mitmKey, data, RS_LENGTH);
+ setMITMKeyAvailable();
+}
+
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-default-style: ellemtel
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/src/Zrtp.cpp b/src/Zrtp.cpp
new file mode 100644
index 0000000..2002462
--- /dev/null
+++ b/src/Zrtp.cpp
@@ -0,0 +1,2527 @@
+/*
+ Copyright (C) 2006-2009 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/>.
+*/
+
+/*F
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+#include <sstream>
+
+#include <libzrtpcpp/crypto/ZrtpDH.h>
+#include <libzrtpcpp/crypto/hmac256.h>
+#include <libzrtpcpp/crypto/sha256.h>
+#include <libzrtpcpp/crypto/hmac384.h>
+#include <libzrtpcpp/crypto/sha384.h>
+#include <libzrtpcpp/crypto/aesCFB.h>
+#include <libzrtpcpp/crypto/twoCFB.h>
+
+#include <libzrtpcpp/ZRtp.h>
+#include <libzrtpcpp/ZrtpStateClass.h>
+#include <libzrtpcpp/ZIDFile.h>
+#include <libzrtpcpp/ZIDRecord.h>
+#include <libzrtpcpp/Base32.h>
+
+using namespace GnuZrtpCodes;
+
+/* disabled...but used in testing and debugging, probably should have a
+ controlling #define...
+ *
+static void hexdump(const char* title, const unsigned char *s, int l) {
+ int n=0;
+
+ if (s == NULL) return;
+
+ fprintf(stderr, "%s",title);
+ for( ; n < l ; ++n)
+ {
+ if((n%16) == 0)
+ fprintf(stderr, "\n%04x",n);
+ fprintf(stderr, " %02x",s[n]);
+ }
+ fprintf(stderr, "\n");
+}
+ */
+
+/*
+ * This method simplifies detection of libzrtpcpp inside Automake, configure
+ * and friends
+ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+ int ZrtpAvailable()
+ {
+ return 1;
+ }
+#ifdef __cplusplus
+}
+#endif
+
+ZRtp::ZRtp(uint8_t *myZid, ZrtpCallback *cb, std::string id, ZrtpConfigure* config, bool mitmm, bool sasSignSupport):
+ callback(cb), dhContext(NULL), DHss(NULL), auxSecret(NULL), auxSecretLength(0), rs1Valid(false),
+ rs2Valid(false), msgShaContext(NULL), multiStream(false), multiStreamAvailable(false), pbxSecretTmp(NULL),
+ configureAlgos(*config) {
+
+ enableMitmEnrollment = config->isTrustedMitM();
+ paranoidMode = config->isParanoidMode();
+
+ // setup the implicit hash function pointers and length
+ hashLengthImpl = SHA256_DIGEST_LENGTH;
+ hashFunctionImpl = sha256;
+ hashListFunctionImpl = sha256;
+
+ hmacFunctionImpl = hmac_sha256;
+ hmacListFunctionImpl = hmac_sha256;
+
+ /*
+ * Generate H0 as a random number (256 bits, 32 bytes) and then
+ * the hash chain, refer to chapter 9. Use the implicit hash function.
+ */
+ randomZRTP(H0, HASH_IMAGE_SIZE);
+ sha256(H0, HASH_IMAGE_SIZE, H1); // hash H0 and generate H1
+ sha256(H1, HASH_IMAGE_SIZE, H2); // H2
+ sha256(H2, HASH_IMAGE_SIZE, H3); // H3
+
+ zrtpHello.configureHello(&configureAlgos);
+ zrtpHello.setH3(H3); // set H3 in Hello, included in helloHash
+
+ memcpy(zid, myZid, ZID_SIZE);
+ zrtpHello.setZid(zid);
+
+ if (mitmm) // this session acts for a trusted MitM (PBX)
+ zrtpHello.setMitmMode();
+
+ if (sasSignSupport) // the application supports SAS signing
+ zrtpHello.setSasSign();
+
+ setClientId(id); // set id, compute HMAC and final helloHash
+
+ stateEngine = new ZrtpStateClass(this);
+}
+
+ZRtp::~ZRtp() {
+ stopZrtp();
+ if (DHss != NULL) {
+ delete DHss;
+ DHss = NULL;
+ }
+ if (stateEngine != NULL) {
+ delete stateEngine;
+ stateEngine = NULL;
+ }
+ if (dhContext != NULL) {
+ delete dhContext;
+ dhContext = NULL;
+ }
+ if (msgShaContext != NULL) {
+ closeHashCtx(msgShaContext, NULL);
+ msgShaContext = NULL;
+ }
+ if (auxSecret != NULL) {
+ delete auxSecret;
+ auxSecret = NULL;
+ auxSecretLength = 0;
+ }
+ memset(hmacKeyI, 0, MAX_DIGEST_LENGTH);
+ memset(hmacKeyR, 0, MAX_DIGEST_LENGTH);
+
+ memset(zrtpKeyI, 0, MAX_DIGEST_LENGTH);
+ memset(zrtpKeyR, 0, MAX_DIGEST_LENGTH);
+ /*
+ * Clear the Initiator's srtp key and salt
+ */
+ memset(srtpKeyI, 0, MAX_DIGEST_LENGTH);
+ memset(srtpSaltI, 0, MAX_DIGEST_LENGTH);
+ /*
+ * Clear he Responder's srtp key and salt
+ */
+ memset(srtpKeyR, 0, MAX_DIGEST_LENGTH);
+ memset(srtpSaltR, 0, MAX_DIGEST_LENGTH);
+
+ memset(zrtpSession, 0, MAX_DIGEST_LENGTH);
+}
+
+void ZRtp::processZrtpMessage(uint8_t *message, uint32_t pSSRC) {
+ Event_t ev;
+
+ peerSSRC = pSSRC;
+ ev.type = ZrtpPacket;
+ ev.packet = message;
+
+ if (stateEngine != NULL) {
+ stateEngine->processEvent(&ev);
+ }
+}
+
+void ZRtp::processTimeout() {
+ Event_t ev;
+
+ ev.type = Timer;
+ if (stateEngine != NULL) {
+ stateEngine->processEvent(&ev);
+ }
+}
+
+#ifdef oldgoclear
+bool ZRtp::handleGoClear(uint8_t *message)
+{
+ char *msg, first, last;
+
+ msg = (char *)message + 4;
+ first = tolower(*msg);
+ last = tolower(*(msg+6));
+
+ if (first == 'g' && last == 'r') {
+ Event_t ev;
+
+ ev.type = ZrtpGoClear;
+ ev.packet = message;
+ if (stateEngine != NULL) {
+ stateEngine->processEvent(&ev);
+ }
+ return true;
+ }
+ else {
+ return false;
+ }
+}
+#endif
+
+void ZRtp::startZrtpEngine() {
+ Event_t ev;
+
+ if (stateEngine != NULL && stateEngine->inState(Initial)) {
+ ev.type = ZrtpInitial;
+ stateEngine->processEvent(&ev);
+ }
+}
+
+void ZRtp::stopZrtp() {
+ Event_t ev;
+
+ if (stateEngine != NULL) {
+ ev.type = ZrtpClose;
+ stateEngine->processEvent(&ev);
+ }
+}
+
+bool ZRtp::inState(int32_t state)
+{
+ if (stateEngine != NULL) {
+ return stateEngine->inState(state);
+ }
+ else {
+ return false;
+ }
+}
+
+ZrtpPacketHello* ZRtp::prepareHello() {
+ return &zrtpHello;
+}
+
+ZrtpPacketHelloAck* ZRtp::prepareHelloAck() {
+ return &zrtpHelloAck;
+}
+
+/*
+ * At this point we will assume the role of Initiator. This role may change
+ * in case we have a commit-clash. Refer to chapter 5.2 in the spec how
+ * to break this tie.
+ */
+ZrtpPacketCommit* ZRtp::prepareCommit(ZrtpPacketHello *hello, uint32_t* errMsg) {
+
+ sendInfo(Info, InfoHelloReceived);
+
+ if (memcmp(hello->getVersion(), zrtpVersion, ZRTP_WORD_SIZE-1) != 0) {
+ *errMsg = UnsuppZRTPVersion;
+ return NULL;
+ }
+ // Save our peer's (presumably the Responder) ZRTP id
+ memcpy(peerZid, hello->getZid(), ZID_SIZE);
+ if (memcmp(peerZid, zid, ZID_SIZE) == 0) { // peers have same ZID????
+ *errMsg = EqualZIDHello;
+ return NULL;
+ }
+ memcpy(peerH3, hello->getH3(), HASH_IMAGE_SIZE);
+
+ /*
+ * The Following section extracts the algorithm from the peer's Hello
+ * packet. Always the preferend offered algorithms are
+ * used. If the received Hello does not contain algo specifiers
+ * or offers only unsupported optional algos then replace
+ * these with mandatory algos and put them into the Commit packet.
+ * Refer to the findBest*() functions.
+ * If this is a MultiStream ZRTP object then do not get the cipher,
+ * authentication from hello packet but use the pre-initialized values
+ * as proposed by the standard. If we switch to responder mode the
+ * commit packet may contain other algos - see function
+ * prepareConfirm2MultiStream(...).
+ */
+ sasType = findBestSASType(hello);
+
+ if (!multiStream) {
+ authLength = findBestAuthLen(hello);
+ pubKey = findBestPubkey(hello);
+ cipher = findBestCipher(hello, pubKey);
+ hash = findBestHash(hello);
+ multiStreamAvailable = checkMultiStream(hello);
+ }
+ else {
+ if (checkMultiStream(hello)) {
+ return prepareCommitMultiStream(hello);
+ }
+ else {
+ // we are in multi-stream but peer does not offer multi-stream
+ // return error code to other party - unsupported PK, must be Mult
+ *errMsg = UnsuppPKExchange;
+ return NULL;
+ }
+ }
+ setNegotiatedHash(hash);
+
+ // Modify here when introducing new DH key agreement, for example
+ // elliptic curves.
+ dhContext = new ZrtpDH(pubKey->getName());
+ dhContext->generatePublicKey();
+
+ dhContext->getPubKeyBytes(pubKeyBytes);
+ sendInfo(Info, InfoCommitDHGenerated);
+
+ // Prepare IV data that we will use during confirm packet encryption.
+ randomZRTP(randomIV, sizeof(randomIV));
+
+ /*
+ * Prepare our DHPart2 packet here. Required to compute HVI. If we stay
+ * in Initiator role then we reuse this packet later in prepareDHPart2().
+ * To create this DH packet we have to compute the retained secret ids
+ * first. Thus get our peer's retained secret data first.
+ */
+ ZIDRecord zidRec(peerZid);
+ ZIDFile *zidFile = ZIDFile::getInstance();
+ zidFile->getRecord(&zidRec);
+
+ //Compute the Initator's and Responder's retained secret ids.
+ computeSharedSecretSet(zidRec);
+
+ // Check if a PBX application set the MitM flag.
+ if (hello->isMitmMode()) {
+ mitmSeen = true;
+ }
+ // Flag to record that fact that we have a MitM key of the other peer.
+ peerIsEnrolled = zidRec.isMITMKeyAvailable();
+
+ signSasSeen = hello->isSasSign();
+ // Construct a DHPart2 message (Initiator's DH message). This packet
+ // is required to compute the HVI (Hash Value Initiator), refer to
+ // chapter 5.4.1.1.
+
+ // Fill the values in the DHPart2 packet
+ zrtpDH2.setPubKeyType(pubKey->getName());
+ zrtpDH2.setMessageType((uint8_t*)DHPart2Msg);
+ zrtpDH2.setRs1Id(rs1IDi);
+ zrtpDH2.setRs2Id(rs2IDi);
+ zrtpDH2.setAuxSecretId(auxSecretIDi);
+ zrtpDH2.setPbxSecretId(pbxSecretIDi);
+ zrtpDH2.setPv(pubKeyBytes);
+ zrtpDH2.setH1(H1);
+
+ int32_t len = zrtpDH2.getLength() * ZRTP_WORD_SIZE;
+
+ // Compute HMAC over DH2, excluding the HMAC field (HMAC_SIZE)
+ // and store in DH2. Key to HMAC is H0, use HASH_IMAGE_SIZE bytes only.
+ // Must use implicit HMAC functions.
+ uint8_t hmac[IMPL_MAX_DIGEST_LENGTH];
+ uint32_t macLen;
+ hmacFunctionImpl(H0, HASH_IMAGE_SIZE, (uint8_t*)zrtpDH2.getHeaderBase(), len-(HMAC_SIZE), hmac, &macLen);
+ zrtpDH2.setHMAC(hmac);
+
+ // Compute the HVI, refer to chapter 5.4.1.1 of the specification
+ computeHvi(&zrtpDH2, hello);
+
+ zrtpCommit.setZid(zid);
+ zrtpCommit.setHashType((uint8_t*)hash->getName());
+ zrtpCommit.setCipherType((uint8_t*)cipher->getName());
+ zrtpCommit.setAuthLen((uint8_t*)authLength->getName());
+ zrtpCommit.setPubKeyType((uint8_t*)pubKey->getName());
+ zrtpCommit.setSasType((uint8_t*)sasType->getName());
+ zrtpCommit.setHvi(hvi);
+ zrtpCommit.setH2(H2);
+
+ len = zrtpCommit.getLength() * ZRTP_WORD_SIZE;
+
+ // Compute HMAC over Commit, excluding the HMAC field (HMAC_SIZE)
+ // and store in Hello. Key to HMAC is H1, use HASH_IMAGE_SIZE bytes only.
+ // Must use implicit HMAC functions.
+ hmacFunctionImpl(H1, HASH_IMAGE_SIZE, (uint8_t*)zrtpCommit.getHeaderBase(), len-(HMAC_SIZE), hmac, &macLen);
+ zrtpCommit.setHMAC(hmac);
+
+ // hash first messages to produce overall message hash
+ // First the Responder's Hello message, second the Commit (always Initator's).
+ // Must use negotiated hash.
+ int32_t helloLen = hello->getLength() * ZRTP_WORD_SIZE;
+ msgShaContext = createHashCtx();
+ hashCtxFunction(msgShaContext, (unsigned char*)hello->getHeaderBase(), helloLen);
+ hashCtxFunction(msgShaContext, (unsigned char*)zrtpCommit.getHeaderBase(), len);
+
+ // store Hello data temporarily until we can check HMAC after receiving Commit as
+ // Responder or DHPart1 as Initiator
+ storeMsgTemp(hello);
+
+ // calculate hash over the received Hello packet - is peer's hello hash.
+ // Use implicit hash algorithm
+ hashFunctionImpl((unsigned char*)hello->getHeaderBase(), helloLen, peerHelloHash);
+ memcpy(peerHelloVersion, hello->getVersion(), ZRTP_WORD_SIZE);
+ peerHelloVersion[ZRTP_WORD_SIZE] = 0;
+
+ return &zrtpCommit;
+}
+
+ZrtpPacketCommit* ZRtp::prepareCommitMultiStream(ZrtpPacketHello *hello) {
+
+ randomZRTP(hvi, ZRTP_WORD_SIZE*4); // This is the Multi-Stream NONCE size
+
+ zrtpCommit.setZid(zid);
+ zrtpCommit.setHashType((uint8_t*)hash->getName());
+ zrtpCommit.setCipherType((uint8_t*)cipher->getName());
+ zrtpCommit.setAuthLen((uint8_t*)authLength->getName());
+ zrtpCommit.setPubKeyType((uint8_t*)"Mult"); // this is fixed because of Multi Stream mode
+ zrtpCommit.setSasType((uint8_t*)sasType->getName());
+ zrtpCommit.setNonce(hvi);
+ zrtpCommit.setH2(H2);
+
+ int32_t len = zrtpCommit.getLength() * ZRTP_WORD_SIZE;
+
+ // Compute HMAC over Commit, excluding the HMAC field (HMAC_SIZE)
+ // and store in Hello. Key to HMAC is H1, use HASH_IMAGE_SIZE bytes only.
+ // Must use the implicit HMAC function.
+ uint8_t hmac[IMPL_MAX_DIGEST_LENGTH];
+ uint32_t macLen;
+ hmacFunctionImpl(H1, HASH_IMAGE_SIZE, (uint8_t*)zrtpCommit.getHeaderBase(), len-(HMAC_SIZE), hmac, &macLen);
+ zrtpCommit.setHMACMulti(hmac);
+
+
+ // hash first messages to produce overall message hash
+ // First the Responder's Hello message, second the Commit
+ // (always Initator's).
+ // Must use the negotiated hash.
+ msgShaContext = createHashCtx();
+
+ int32_t helloLen = hello->getLength() * ZRTP_WORD_SIZE;
+ hashCtxFunction(msgShaContext, (unsigned char*)hello->getHeaderBase(), helloLen);
+ hashCtxFunction(msgShaContext, (unsigned char*)zrtpCommit.getHeaderBase(), len);
+
+ // store Hello data temporarily until we can check HMAC after receiving Commit as
+ // Responder or DHPart1 as Initiator
+ storeMsgTemp(hello);
+
+ // calculate hash over the received Hello packet - is peer's hello hash.
+ // Use implicit hash algorithm
+ hashFunctionImpl((unsigned char*)hello->getHeaderBase(), helloLen, peerHelloHash);
+ memcpy(peerHelloVersion, hello->getVersion(), ZRTP_WORD_SIZE);
+ peerHelloVersion[ZRTP_WORD_SIZE] = 0;
+
+ return &zrtpCommit;
+}
+
+/*
+ * At this point we will take the role of the Responder. We may have been in
+ * the role of the Initiator before and already sent a commit packet that
+ * clashed with a commit packet from our peer. If our HVI was lower than our
+ * peer's HVI then we switched to Responder and handle our peer's commit packet
+ * here. This method takes care to delete and refresh data left over from a
+ * possible Initiator preparation. This belongs to prepared DH data, message
+ * hash SHA context
+ */
+ZrtpPacketDHPart* ZRtp::prepareDHPart1(ZrtpPacketCommit *commit, uint32_t* errMsg) {
+
+ sendInfo(Info, InfoRespCommitReceived);
+
+ // The following code check the hash chain according chapter 10 to detect
+ // false ZRTP packets.
+ // Must use the implicit hash function.
+ uint8_t tmpH3[IMPL_MAX_DIGEST_LENGTH];
+ memcpy(peerH2, commit->getH2(), HASH_IMAGE_SIZE);
+ hashFunctionImpl(peerH2, HASH_IMAGE_SIZE, tmpH3);
+
+ if (memcmp(tmpH3, peerH3, HASH_IMAGE_SIZE) != 0) {
+ *errMsg = IgnorePacket;
+ return NULL;
+ }
+
+ // Check HMAC of previous Hello packet stored in temporary buffer. The
+ // HMAC key of peer's Hello packet is peer's H2 that is contained in the
+ // Commit packet. Refer to chapter 9.1.
+ if (!checkMsgHmac(peerH2)) {
+ sendInfo(Severe, SevereHelloHMACFailed);
+ *errMsg = CriticalSWError;
+ return NULL;
+ }
+
+ // check if we support the commited Cipher type
+ AlgorithmEnum* cp = &zrtpSymCiphers.getByName((const char*)commit->getCipherType());
+ if (!cp->isValid()) { // no match - something went wrong
+ *errMsg = UnsuppCiphertype;
+ return NULL;
+ }
+ cipher = cp;
+
+ // check if we support the commited Authentication length
+ cp = &zrtpAuthLengths.getByName((const char*)commit->getAuthLen());
+ if (!cp->isValid()) { // no match - something went wrong
+ *errMsg = UnsuppSRTPAuthTag;
+ return NULL;
+ }
+ authLength = cp;
+
+ // check if we support the commited hash type
+ cp = &zrtpHashes.getByName((const char*)commit->getHashType());
+ if (!cp->isValid()) { // no match - something went wrong
+ *errMsg = UnsuppHashType;
+ return NULL;
+ }
+ // check if the peer's commited hash is the same that we used when
+ // preparing our commit packet. If not do the necessary resets and
+ // recompute some data.
+ if (*(int32_t*)(hash->getName()) != *(int32_t*)(cp->getName())) {
+ hash = cp;
+ setNegotiatedHash(hash);
+
+ ZIDRecord zidRec(peerZid);
+ ZIDFile *zidFile = ZIDFile::getInstance();
+ zidFile->getRecord(&zidRec);
+
+ // Compute the Initator's and Responder's retained secret ids
+ // with the committed hash.
+ computeSharedSecretSet(zidRec);
+ }
+
+ // check if we support the commited pub key type
+ cp = &zrtpPubKeys.getByName((const char*)commit->getPubKeysType());
+ if (!cp->isValid()) { // no match - something went wrong
+ *errMsg = UnsuppPKExchange;
+ return NULL;
+ }
+ pubKey = cp;
+
+ // check if we support the commited SAS type
+ cp = &zrtpSasTypes.getByName((const char*)commit->getSasType());
+ if (!cp->isValid()) { // no match - something went wrong
+ *errMsg = UnsuppSASScheme;
+ return NULL;
+ }
+ sasType = cp;
+
+ // dhContext cannot be NULL - always setup during prepareCommit()
+ // check if we can use the dhContext prepared by prepareCOmmit(),
+ // if not delete old DH context and generate new one
+ // The algorithm names are 4 chars only, thus we can cast to int32_t
+ if (*(int32_t*)(dhContext->getDHtype()) != *(int32_t*)(pubKey->getName())) {
+ delete dhContext;
+ dhContext = new ZrtpDH(pubKey->getName());
+ dhContext->generatePublicKey();
+ }
+ sendInfo(Info, InfoDH1DHGenerated);
+
+ dhContext->getPubKeyBytes(pubKeyBytes);
+
+ // Setup a DHPart1 packet.
+ zrtpDH1.setPubKeyType(pubKey->getName());
+ zrtpDH1.setMessageType((uint8_t*)DHPart1Msg);
+ zrtpDH1.setRs1Id(rs1IDr);
+ zrtpDH1.setRs2Id(rs2IDr);
+ zrtpDH1.setAuxSecretId(auxSecretIDr);
+ zrtpDH1.setPbxSecretId(pbxSecretIDr);
+ zrtpDH1.setPv(pubKeyBytes);
+ zrtpDH1.setH1(H1);
+
+ int32_t len = zrtpDH1.getLength() * ZRTP_WORD_SIZE;
+
+ // Compute HMAC over DHPart1, excluding the HMAC field (HMAC_SIZE)
+ // and store in DHPart1.
+ // Use implicit Hash function
+ uint8_t hmac[IMPL_MAX_DIGEST_LENGTH];
+ uint32_t macLen;
+ hmacFunctionImpl(H0, HASH_IMAGE_SIZE, (uint8_t*)zrtpDH1.getHeaderBase(), len-(HMAC_SIZE), hmac, &macLen);
+ zrtpDH1.setHMAC(hmac);
+
+ // We are definitly responder. Save the peer's hvi for later compare.
+ myRole = Responder;
+ memcpy(peerHvi, commit->getHvi(), HVI_SIZE);
+
+ // We are responder. Release a possibly pre-computed SHA context
+ // because this was prepared for Initiator. Then create a new one.
+ if (msgShaContext != NULL) {
+ closeHashCtx(msgShaContext, NULL);
+ }
+ msgShaContext = createHashCtx();
+
+ // Hash messages to produce overall message hash:
+ // First the Responder's (my) Hello message, second the Commit
+ // (always Initator's), then the DH1 message (which is always a
+ // Responder's message).
+ // Must use negotiated hash
+ hashCtxFunction(msgShaContext, (unsigned char*)zrtpHello.getHeaderBase(), zrtpHello.getLength() * ZRTP_WORD_SIZE);
+ hashCtxFunction(msgShaContext, (unsigned char*)commit->getHeaderBase(), commit->getLength() * ZRTP_WORD_SIZE);
+ hashCtxFunction(msgShaContext, (unsigned char*)zrtpDH1.getHeaderBase(), zrtpDH1.getLength() * ZRTP_WORD_SIZE);
+
+ // store Commit data temporarily until we can check HMAC after we got DHPart2
+ storeMsgTemp(commit);
+
+ return &zrtpDH1;
+}
+
+/*
+ * At this point we will take the role of the Initiator.
+ */
+ZrtpPacketDHPart* ZRtp::prepareDHPart2(ZrtpPacketDHPart *dhPart1, uint32_t* errMsg) {
+
+ uint8_t* pvr;
+
+ sendInfo(Info, InfoInitDH1Received);
+
+ // Because we are initiator the protocol engine didn't receive Commit
+ // thus could not store a peer's H2. A two step SHA256 is required to
+ // re-compute H3. Then compare with peer's H3 from peer's Hello packet.
+ // Must use implicit hash function.
+ uint8_t tmpHash[IMPL_MAX_DIGEST_LENGTH];
+ hashFunctionImpl(dhPart1->getH1(), HASH_IMAGE_SIZE, tmpHash); // Compute peer's H2
+ memcpy(peerH2, tmpHash, HASH_IMAGE_SIZE);
+ hashFunctionImpl(peerH2, HASH_IMAGE_SIZE, tmpHash); // Compute peer's H3 (tmpHash)
+
+ if (memcmp(tmpHash, peerH3, HASH_IMAGE_SIZE) != 0) {
+ *errMsg = IgnorePacket;
+ return NULL;
+ }
+
+ // Check HMAC of previous Hello packet stored in temporary buffer. The
+ // HMAC key of the Hello packet is peer's H2 that was computed above.
+ // Refer to chapter 9.1 and chapter 10.
+ if (!checkMsgHmac(peerH2)) {
+ sendInfo(Severe, SevereHelloHMACFailed);
+ *errMsg = CriticalSWError;
+ return NULL;
+ }
+
+ // get memory to store DH result TODO: make it fixed memory
+ DHss = new uint8_t[dhContext->getDhSize()];
+ if (DHss == NULL) {
+ *errMsg = CriticalSWError;
+ return NULL;
+ }
+
+ // get and check Responder's public value, see chap. 5.4.3 in the spec
+ pvr = dhPart1->getPv();
+ if (!dhContext->checkPubKey(pvr)) {
+ *errMsg = DHErrorWrongPV;
+ return NULL;
+ }
+ dhContext->computeSecretKey(pvr, DHss);
+
+ myRole = Initiator;
+
+ // We are Initiator: the Responder's Hello and the Initiator's (our) Commit
+ // are already hashed in the context. Now hash the Responder's DH1 and then
+ // the Initiator's (our) DH2 in that order.
+ // Use the negotiated hash function.
+ hashCtxFunction(msgShaContext, (unsigned char*)dhPart1->getHeaderBase(), dhPart1->getLength() * ZRTP_WORD_SIZE);
+ hashCtxFunction(msgShaContext, (unsigned char*)zrtpDH2.getHeaderBase(), zrtpDH2.getLength() * ZRTP_WORD_SIZE);
+
+ // Compute the message Hash
+ closeHashCtx(msgShaContext, messageHash);
+ msgShaContext = NULL;
+
+ // To compute the keys for the Initiator we need the retained secrets of our
+ // peer. Get them from the storage.
+ ZIDRecord zidRec(peerZid);
+ ZIDFile *zid = ZIDFile::getInstance();
+ zid->getRecord(&zidRec);
+
+ // Now compute the S0, all dependend keys and the new RS1. The function
+ // also performs sign SAS callback if it's active.
+ generateKeysInitiator(dhPart1, zidRec);
+ zid->saveRecord(&zidRec);
+
+ delete dhContext;
+ dhContext = NULL;
+
+ // TODO: at initiator we can call signSAS at this point, don't dealy until confirm1 reveived
+ // store DHPart1 data temporarily until we can check HMAC after receiving Confirm1
+ storeMsgTemp(dhPart1);
+ return &zrtpDH2;
+}
+
+/*
+ * At this point we are Responder.
+ */
+ZrtpPacketConfirm* ZRtp::prepareConfirm1(ZrtpPacketDHPart* dhPart2, uint32_t* errMsg) {
+
+ uint8_t* pvi;
+
+ sendInfo(Info, InfoRespDH2Received);
+
+ // Because we are responder we received a Commit and stored its H2.
+ // Now re-compute H2 from received H1 and compare with stored peer's H2.
+ // Use implicit hash function
+ uint8_t tmpHash[IMPL_MAX_DIGEST_LENGTH];
+ hashFunctionImpl(dhPart2->getH1(), HASH_IMAGE_SIZE, tmpHash);
+ if (memcmp(tmpHash, peerH2, HASH_IMAGE_SIZE) != 0) {
+ *errMsg = IgnorePacket;
+ return NULL;
+ }
+
+ // Check HMAC of Commit packet stored in temporary buffer. The
+ // HMAC key of the Commit packet is peer's H1 that is contained in
+ // DHPart2. Refer to chapter 9.1 and chapter 10.
+ if (!checkMsgHmac(dhPart2->getH1())) {
+ sendInfo(Severe, SevereCommitHMACFailed);
+ *errMsg = CriticalSWError;
+ return NULL;
+ }
+ // Now we have the peer's pvi. Because we are responder re-compute my hvi
+ // using my Hello packet and the Initiator's DHPart2 and compare with
+ // hvi sent in commit packet. If it doesn't macht then a MitM attack
+ // may have occured.
+ computeHvi(dhPart2, &zrtpHello);
+ if (memcmp(hvi, peerHvi, HVI_SIZE) != 0) {
+ *errMsg = DHErrorWrongHVI;
+ return NULL;
+ }
+ DHss = new uint8_t[dhContext->getDhSize()];
+ if (DHss == NULL) {
+ *errMsg = CriticalSWError;
+ return NULL;
+ }
+ // Get and check the Initiator's public value, see chap. 5.4.2 of the spec
+ pvi = dhPart2->getPv();
+ if (!dhContext->checkPubKey(pvi)) {
+ *errMsg = DHErrorWrongPV;
+ return NULL;
+ }
+ dhContext->computeSecretKey(pvi, DHss);
+ // Hash the Initiator's DH2 into the message Hash (other messages already
+ // prepared, see method prepareDHPart1().
+ // Use neotiated hash function
+ hashCtxFunction(msgShaContext, (unsigned char*)dhPart2->getHeaderBase(), dhPart2->getLength() * ZRTP_WORD_SIZE);
+
+ closeHashCtx(msgShaContext, messageHash);
+ msgShaContext = NULL;
+
+ // To compute the Keys for the Initiator we need the retained secrets of our
+ // peer. Get them from the storage.
+ ZIDRecord zidRec(peerZid);
+ ZIDFile *zid = ZIDFile::getInstance();
+ zid->getRecord(&zidRec);
+
+ /*
+ * The expected shared secret Ids were already computed when we built the
+ * DHPart1 packet. Generate s0, all depended keys, and the new RS1 value
+ * for the ZID record. The functions also performs sign SAS callback if it's active.
+ */
+ generateKeysResponder(dhPart2, zidRec);
+ zid->saveRecord(&zidRec);
+
+ delete dhContext;
+ dhContext = NULL;
+
+ // Fill in Confirm1 packet.
+ zrtpConfirm1.setMessageType((uint8_t*)Confirm1Msg);
+
+ // Check if user verfied the SAS in a previous call and thus verfied
+ // the retained secret. Don't set the verified flag if paranoidMode is true.
+ if (zidRec.isSasVerified() && !paranoidMode) {
+ zrtpConfirm1.setSASFlag();
+ }
+ zrtpConfirm1.setExpTime(0xFFFFFFFF);
+ zrtpConfirm1.setIv(randomIV);
+ zrtpConfirm1.setHashH0(H0);
+
+ // if this run at PBX user agent enrollment service then set flag in confirm
+ // packet and store the MitM key
+ if (enrollmentMode) {
+ computePBXSecret();
+ zrtpConfirm1.setPBXEnrollment();
+ writeEnrollmentPBX();
+ }
+ uint8_t confMac[MAX_DIGEST_LENGTH];
+ uint32_t macLen;
+
+ // Encrypt and HMAC with Responder's key - we are Respondere here
+ int hmlen = (zrtpConfirm1.getLength() - 9) * ZRTP_WORD_SIZE;
+ cipher->getEncrypt()(zrtpKeyR, cipher->getKeylen(), randomIV, zrtpConfirm1.getHashH0(), hmlen);
+ hmacFunction(hmacKeyR, hashLength, (unsigned char*)zrtpConfirm1.getHashH0(), hmlen, confMac, &macLen);
+
+ zrtpConfirm1.setHmac(confMac);
+
+ // store DHPart2 data temporarily until we can check HMAC after receiving Confirm2
+ storeMsgTemp(dhPart2);
+ return &zrtpConfirm1;
+}
+
+/*
+ * At this point we are Responder.
+ */
+ZrtpPacketConfirm* ZRtp::prepareConfirm1MultiStream(ZrtpPacketCommit* commit, uint32_t* errMsg) {
+
+ sendInfo(Info, InfoRespCommitReceived);
+
+ // The following code checks the hash chain according chapter 10 to detect
+ // false ZRTP packets.
+ // Use implicit hash function
+ uint8_t tmpH3[IMPL_MAX_DIGEST_LENGTH];
+ memcpy(peerH2, commit->getH2(), HASH_IMAGE_SIZE);
+ hashFunctionImpl(peerH2, HASH_IMAGE_SIZE, tmpH3);
+
+ if (memcmp(tmpH3, peerH3, HASH_IMAGE_SIZE) != 0) {
+ *errMsg = IgnorePacket;
+ return NULL;
+ }
+
+ // Check HMAC of previous Hello packet stored in temporary buffer. The
+ // HMAC key of peer's Hello packet is peer's H2 that is contained in the
+ // Commit packet. Refer to chapter 9.1.
+ if (!checkMsgHmac(peerH2)) {
+ sendInfo(Severe, SevereHelloHMACFailed);
+ *errMsg = CriticalSWError;
+ return NULL;
+ }
+
+ // check if Commit contains "Mult" as pub key type
+ AlgorithmEnum* cp = &zrtpPubKeys.getByName((const char*)commit->getPubKeysType());
+ if (!cp->isValid() || *(int32_t*)(cp->getName()) != *(int32_t*)mult) {
+ *errMsg = UnsuppPKExchange;
+ return NULL;
+ }
+
+ // check if we support the commited cipher
+ cp = &zrtpSymCiphers.getByName((const char*)commit->getCipherType());
+ if (!cp->isValid()) { // no match - something went wrong
+ *errMsg = UnsuppCiphertype;
+ return NULL;
+ }
+ cipher = cp;
+
+ // check if we support the commited Authentication length
+ cp = &zrtpAuthLengths.getByName((const char*)commit->getAuthLen());
+ if (!cp->isValid()) { // no match - something went wrong
+ *errMsg = UnsuppSRTPAuthTag;
+ return NULL;
+ }
+ authLength = cp;
+
+ // check if we support the commited hash type
+ cp = &zrtpHashes.getByName((const char*)commit->getHashType());
+ if (!cp->isValid()) { // no match - something went wrong
+ *errMsg = UnsuppHashType;
+ return NULL;
+ }
+ // check if the peer's commited hash is the same that we used when
+ // preparing our commit packet. If not do the necessary resets and
+ // recompute some data.
+ if (*(int32_t*)(hash->getName()) != *(int32_t*)(cp->getName())) {
+ hash = cp;
+ setNegotiatedHash(hash);
+ }
+ myRole = Responder;
+
+ // We are responder. Release a possibly pre-computed SHA256 context
+ // because this was prepared for Initiator. Then create a new one.
+ if (msgShaContext != NULL) {
+ closeHashCtx(msgShaContext, NULL);
+ }
+ msgShaContext = createHashCtx();
+
+ // Hash messages to produce overall message hash:
+ // First the Responder's (my) Hello message, second the Commit
+ // (always Initator's)
+ // use negotiated hash
+ hashCtxFunction(msgShaContext, (unsigned char*)zrtpHello.getHeaderBase(), zrtpHello.getLength() * ZRTP_WORD_SIZE);
+ hashCtxFunction(msgShaContext, (unsigned char*)commit->getHeaderBase(), commit->getLength() * ZRTP_WORD_SIZE);
+
+ closeHashCtx(msgShaContext, messageHash);
+ msgShaContext = NULL;
+
+ generateKeysMultiStream();
+
+ // Fill in Confirm1 packet.
+ zrtpConfirm1.setMessageType((uint8_t*)Confirm1Msg);
+ zrtpConfirm1.setExpTime(0xFFFFFFFF);
+ zrtpConfirm1.setIv(randomIV);
+ zrtpConfirm1.setHashH0(H0);
+
+ uint8_t confMac[MAX_DIGEST_LENGTH];
+ uint32_t macLen;
+
+ // Encrypt and HMAC with Responder's key - we are Respondere here
+ int32_t hmlen = (zrtpConfirm1.getLength() - 9) * ZRTP_WORD_SIZE;
+ cipher->getEncrypt()(zrtpKeyR, cipher->getKeylen(), randomIV, zrtpConfirm1.getHashH0(), hmlen);
+
+ // Use negotiated HMAC (hash)
+ hmacFunction(hmacKeyR, hashLength, (unsigned char*)zrtpConfirm1.getHashH0(), hmlen, confMac, &macLen);
+
+ zrtpConfirm1.setHmac(confMac);
+
+ // Store Commit data temporarily until we can check HMAC after receiving Confirm2
+ storeMsgTemp(commit);
+ return &zrtpConfirm1;
+}
+
+/*
+ * At this point we are Initiator.
+ */
+ZrtpPacketConfirm* ZRtp::prepareConfirm2(ZrtpPacketConfirm* confirm1, uint32_t* errMsg) {
+
+ sendInfo(Info, InfoInitConf1Received);
+
+ uint8_t confMac[MAX_DIGEST_LENGTH];
+ uint32_t macLen;
+
+ // Use the Responder's keys here because we are Initiator here and
+ // receive packets from Responder
+ int16_t hmlen = (confirm1->getLength() - 9) * ZRTP_WORD_SIZE;
+
+ // Use negotiated HMAC (hash)
+ hmacFunction(hmacKeyR, hashLength, (unsigned char*)confirm1->getHashH0(), hmlen, confMac, &macLen);
+
+ if (memcmp(confMac, confirm1->getHmac(), HMAC_SIZE) != 0) {
+ *errMsg = ConfirmHMACWrong;
+ return NULL;
+ }
+ cipher->getDecrypt()(zrtpKeyR, cipher->getKeylen(), confirm1->getIv(), confirm1->getHashH0(), hmlen);
+
+ std::string cs(cipher->getReadable());
+ cs.append("/").append(pubKey->getName());
+
+ // Check HMAC of DHPart1 packet stored in temporary buffer. The
+ // HMAC key of the DHPart1 packet is peer's H0 that is contained in
+ // Confirm1. Refer to chapter 9.
+ if (!checkMsgHmac(confirm1->getHashH0())) {
+ sendInfo(Severe, SevereDH1HMACFailed);
+ *errMsg = CriticalSWError;
+ return NULL;
+ }
+ signatureLength = confirm1->getSignatureLength();
+ if (signSasSeen && signatureLength > 0) {
+ signatureData = confirm1->getSignatureData();
+ callback->checkSASSignature(sasHash);
+ // TODO: error handling if checkSASSignature returns false.
+ }
+ /*
+ * The Confirm1 is ok, handle the Retained secret stuff and inform
+ * GUI about state.
+ */
+ bool sasFlag = confirm1->isSASFlag();
+
+ // Initialize a ZID record to get peer's retained secrets
+ ZIDRecord zidRec(peerZid);
+
+ ZIDFile *zid = ZIDFile::getInstance();
+ zid->getRecord(&zidRec);
+
+ // Our peer did not confirm the SAS in last session, thus reset
+ // our SAS flag too. Reset the flag also if paranoidMode is true.
+ if (!sasFlag || paranoidMode) {
+ zidRec.resetSasVerified();
+ }
+ // get verified flag from current RS1 before set a new RS1. This
+ // may not be set even if peer's flag is set in confirm1 message.
+ sasFlag = zidRec.isSasVerified();
+
+ callback->srtpSecretsOn(cs, SAS, sasFlag);
+
+ // now we are ready to save the new RS1 which inherits the verified
+ // flag from old RS1
+ zidRec.setNewRs1((const uint8_t*)newRs1);
+ zid->saveRecord(&zidRec);
+
+ // now generate my Confirm2 message
+ zrtpConfirm2.setMessageType((uint8_t*)Confirm2Msg);
+ zrtpConfirm2.setHashH0(H0);
+
+ if (sasFlag) {
+ zrtpConfirm2.setSASFlag();
+ }
+ zrtpConfirm2.setExpTime(0xFFFFFFFF);
+ zrtpConfirm2.setIv(randomIV);
+
+ // Compute PBX secret if we are in enrollemnt mode (PBX user agent)
+ // or enrollment was enabled at normal user agent and flag in confirm packet
+ if (enrollmentMode || (enableMitmEnrollment && confirm1->isPBXEnrollment())) {
+ computePBXSecret();
+
+ // if this runs at PBX user agent enrollment service then set flag in confirm
+ // packet and store the MitM key. The PBX user agent service always stores
+ // its MitM key.
+ if (enrollmentMode) {
+ zrtpConfirm2.setPBXEnrollment();
+ writeEnrollmentPBX();
+ }
+ }
+ // Encrypt and HMAC with Initiator's key - we are Initiator here
+ hmlen = (zrtpConfirm2.getLength() - 9) * ZRTP_WORD_SIZE;
+ cipher->getEncrypt()(zrtpKeyI, cipher->getKeylen(), randomIV, zrtpConfirm2.getHashH0(), hmlen);
+
+ // Use negotiated HMAC (hash)
+ hmacFunction(hmacKeyI, hashLength, (unsigned char*)zrtpConfirm2.getHashH0(), hmlen, confMac, &macLen);
+
+ zrtpConfirm2.setHmac(confMac);
+
+ // Ask for enrollment only if enabled via configuration and the
+ // confirm1 packet contains the enrollment flag. The enrolling user
+ // agent stores the MitM key only if the user accepts the enrollment
+ // request.
+ if (enableMitmEnrollment && confirm1->isPBXEnrollment()) {
+ callback->zrtpAskEnrollment(EnrollmentRequest);
+ }
+ return &zrtpConfirm2;
+}
+
+/**
+ * Save the computed MitM secret to the ZID record of the peer
+ */
+void ZRtp::writeEnrollmentPBX() {
+ // Initialize a ZID record to get peer's retained secrets
+ ZIDRecord zidRec(peerZid);
+
+ ZIDFile *zid = ZIDFile::getInstance();
+ zid->getRecord(&zidRec);
+
+ if (pbxSecretTmp != NULL) {
+ zidRec.setMiTMData(pbxSecretTmp);
+ }
+ zid->saveRecord(&zidRec);
+}
+
+/*
+ * At this point we are Initiator.
+ */
+ZrtpPacketConfirm* ZRtp::prepareConfirm2MultiStream(ZrtpPacketConfirm* confirm1, uint32_t* errMsg) {
+
+ // check Confirm1 packet using the keys
+ // prepare Confirm2 packet
+ // don't update SAS, RS
+ sendInfo(Info, InfoInitConf1Received);
+
+ uint8_t confMac[MAX_DIGEST_LENGTH];
+ uint32_t macLen;
+
+ closeHashCtx(msgShaContext, messageHash);
+ msgShaContext = NULL;
+ myRole = Initiator;
+
+ generateKeysMultiStream();
+
+ // Use the Responder's keys here because we are Initiator here and
+ // receive packets from Responder
+ int32_t hmlen = (confirm1->getLength() - 9) * ZRTP_WORD_SIZE;
+
+ // Use negotiated HMAC (hash)
+ hmacFunction(hmacKeyR, hashLength, (unsigned char*)confirm1->getHashH0(), hmlen, confMac, &macLen);
+
+ if (memcmp(confMac, confirm1->getHmac(), HMAC_SIZE) != 0) {
+ *errMsg = ConfirmHMACWrong;
+ return NULL;
+ }
+ cipher->getDecrypt()(zrtpKeyR, cipher->getKeylen(), confirm1->getIv(), confirm1->getHashH0(), hmlen);
+ std::string cs(cipher->getReadable());
+
+ // Because we are initiator the protocol engine didn't receive Commit and
+ // because we are using multi-stream mode here we also did not receive a DHPart1 and
+ // thus could not store a responder's H2 or H1. A two step hash is required to
+ // re-compute H1, H2.
+ // USe implicit hash function.
+ uint8_t tmpHash[IMPL_MAX_DIGEST_LENGTH];
+ hashFunctionImpl(confirm1->getHashH0(), HASH_IMAGE_SIZE, tmpHash); // Compute peer's H1 in tmpHash
+ hashFunctionImpl(tmpHash, HASH_IMAGE_SIZE, tmpHash); // Compute peer's H2 in tmpHash
+ memcpy(peerH2, tmpHash, HASH_IMAGE_SIZE); // copy and truncate to peerH2
+
+ // Check HMAC of previous Hello packet stored in temporary buffer. The
+ // HMAC key of the Hello packet is peer's H2 that was computed above.
+ // Refer to chapter 9.1 and chapter 10.
+ if (!checkMsgHmac(peerH2)) {
+ sendInfo(Severe, SevereHelloHMACFailed);
+ *errMsg = CriticalSWError;
+ return NULL;
+ }
+ // TODO: here we have a SAS signature from reponder, call checkSASsignature (save / compare in case of resend)
+
+ // Inform GUI about security state, don't show SAS and its state
+ std::string cs1("");
+ callback->srtpSecretsOn(cs, cs1, true);
+
+ // now generate my Confirm2 message
+ zrtpConfirm2.setMessageType((uint8_t*)Confirm2Msg);
+ zrtpConfirm2.setHashH0(H0);
+ zrtpConfirm2.setExpTime(0xFFFFFFFF);
+ zrtpConfirm2.setIv(randomIV);
+
+ // Encrypt and HMAC with Initiator's key - we are Initiator here
+ hmlen = (zrtpConfirm2.getLength() - 9) * ZRTP_WORD_SIZE;
+ cipher->getEncrypt()(zrtpKeyI, cipher->getKeylen(), randomIV, zrtpConfirm2.getHashH0(), hmlen);
+
+ // Use negotiated HMAC (hash)
+ hmacFunction(hmacKeyI, hashLength, (unsigned char*)zrtpConfirm2.getHashH0(), hmlen, confMac, &macLen);
+
+ zrtpConfirm2.setHmac(confMac);
+ return &zrtpConfirm2;
+}
+
+/*
+ * At this point we are Responder.
+ */
+ZrtpPacketConf2Ack* ZRtp::prepareConf2Ack(ZrtpPacketConfirm *confirm2, uint32_t* errMsg) {
+
+ sendInfo(Info, InfoRespConf2Received);
+
+ uint8_t confMac[MAX_DIGEST_LENGTH];
+ uint32_t macLen;
+
+ // Use the Initiator's keys here because we are Responder here and
+ // reveice packets from Initiator
+ int16_t hmlen = (confirm2->getLength() - 9) * ZRTP_WORD_SIZE;
+
+ // Use negotiated HMAC (hash)
+ hmacFunction(hmacKeyI, hashLength,
+ (unsigned char*)confirm2->getHashH0(),
+ hmlen, confMac, &macLen);
+
+ if (memcmp(confMac, confirm2->getHmac(), HMAC_SIZE) != 0) {
+ *errMsg = ConfirmHMACWrong;
+ return NULL;
+ }
+ cipher->getDecrypt()(zrtpKeyI, cipher->getKeylen(), confirm2->getIv(), confirm2->getHashH0(), hmlen);
+
+ std::string cs(cipher->getReadable());
+
+ if (!multiStream) {
+ // Check HMAC of DHPart2 packet stored in temporary buffer. The
+ // HMAC key of the DHPart2 packet is peer's H0 that is contained in
+ // Confirm2. Refer to chapter 9.1 and chapter 10.
+ if (!checkMsgHmac(confirm2->getHashH0())) {
+ sendInfo(Severe, SevereDH2HMACFailed);
+ *errMsg = CriticalSWError;
+ return NULL;
+ }
+ signatureLength = confirm2->getSignatureLength();
+ if (signSasSeen && signatureLength > 0) {
+ signatureData = confirm2->getSignatureData();
+ callback->checkSASSignature(sasHash);
+ // TODO: error handling if checkSASSignature returns false.
+ }
+ /*
+ * The Confirm2 is ok, handle the Retained secret stuff and inform
+ * GUI about state.
+ */
+ bool sasFlag = confirm2->isSASFlag();
+
+ // Initialize a ZID record to get peer's retained secrets
+ ZIDRecord zidRec(peerZid);
+
+ ZIDFile *zid = ZIDFile::getInstance();
+ zid->getRecord(&zidRec);
+
+ // Our peer did not confirm the SAS in last session, thus reset
+ // our SAS flag too. Reset the flag also if paranoidMode is true.
+ if (!sasFlag || paranoidMode) {
+ zidRec.resetSasVerified();
+ }
+
+ // Now get the resulting SAS verified flag from current RS1 before setting a new RS1.
+ // It's a combination of our SAS verfied flag and peer's verified flag. Only if both
+ // were set (true) then sasFlag becomes true.
+ sasFlag = zidRec.isSasVerified();
+ cs.append("/").append(pubKey->getName());
+ callback->srtpSecretsOn(cs, SAS, sasFlag);
+
+ // save new RS1, this inherits the verified flag from old RS1
+ zidRec.setNewRs1((const uint8_t*)newRs1);
+ zid->saveRecord(&zidRec);
+
+ // Ask for enrollment only if enabled via configuration and the
+ // confirm packet contains the enrollment flag. The enrolling user
+ // agent stores the MitM key only if the user accepts the enrollment
+ // request.
+ if (enableMitmEnrollment && confirm2->isPBXEnrollment()) {
+ computePBXSecret();
+ callback->zrtpAskEnrollment(EnrollmentRequest);
+ }
+ }
+ else {
+ // Check HMAC of Commit packet stored in temporary buffer. The
+ // HMAC key of the Commit packet is initiator's H1
+ // use implicit hash function.
+ uint8_t tmpHash[IMPL_MAX_DIGEST_LENGTH];
+ hashFunctionImpl(confirm2->getHashH0(), HASH_IMAGE_SIZE, tmpHash); // Compute initiator's H1 in tmpHash
+
+ if (!checkMsgHmac(tmpHash)) {
+ sendInfo(Severe, SevereCommitHMACFailed);
+ *errMsg = CriticalSWError;
+ return NULL;
+ }
+ std::string cs1("");
+
+ // Inform GUI about security state, don't show SAS and its state
+ callback->srtpSecretsOn(cs, cs1, true);
+ }
+ return &zrtpConf2Ack;
+}
+
+ZrtpPacketErrorAck* ZRtp::prepareErrorAck(ZrtpPacketError* epkt) {
+ sendInfo(ZrtpError, epkt->getErrorCode() * -1);
+ return &zrtpErrorAck;
+}
+
+ZrtpPacketError* ZRtp::prepareError(uint32_t errMsg) {
+ zrtpError.setErrorCode(errMsg);
+ return &zrtpError;
+}
+
+ZrtpPacketPingAck* ZRtp::preparePingAck(ZrtpPacketPing* ppkt) {
+ if (ppkt->getLength() != 6) // A PING packet must have a length of 6 words
+ return NULL;
+ // Because we do not support ZRTP proxy mode use the truncated ZID.
+ // If this code shall be used in ZRTP proxy implementation the computation
+ // of the endpoint hash must be enhanced (see chaps 5.15ff and 5.16)
+ zrtpPingAck.setLocalEpHash(zid);
+ zrtpPingAck.setRemoteEpHash(ppkt->getEpHash());
+ zrtpPingAck.setSSRC(peerSSRC);
+ return &zrtpPingAck;
+}
+
+ZrtpPacketRelayAck* ZRtp::prepareRelayAck(ZrtpPacketSASrelay* srly, uint32_t* errMsg) {
+ // handle and render SAS relay data only if the peer announced that it is a trusted
+ // PBX. Don't handle SAS relay in paranoidMode.
+ if (!mitmSeen || paranoidMode)
+ return &zrtpRelayAck;
+
+ uint8_t* hkey, *ekey;
+ // If we are responder then the PBX used it's Initiator keys
+ if (myRole == Responder) {
+ hkey = hmacKeyI;
+ ekey = zrtpKeyI;
+ }
+ else {
+ hkey = hmacKeyR;
+ ekey = zrtpKeyR;
+ }
+
+ uint8_t confMac[MAX_DIGEST_LENGTH];
+ uint32_t macLen;
+
+ // Use the Initiator's keys here because we are Responder here and
+ // reveice packets from Initiator
+ int16_t hmlen = (srly->getLength() - 9) * ZRTP_WORD_SIZE;
+
+ // Use negotiated HMAC (hash)
+ hmacFunction(hkey, hashLength, (unsigned char*)srly->getFiller(), hmlen, confMac, &macLen);
+
+ if (memcmp(confMac, srly->getHmac(), HMAC_SIZE) != 0) {
+ *errMsg = ConfirmHMACWrong;
+ return NULL; // TODO - check error handling
+ }
+ cipher->getDecrypt()(ekey, cipher->getKeylen(), srly->getIv(), (uint8_t*)srly->getFiller(), hmlen);
+
+ const uint8_t* render = srly->getSas();
+ const uint8_t* newSasHash = srly->getTrustedSas();
+
+ bool sasHashNull = true;
+ for (int i = 0; i < HASH_IMAGE_SIZE; i++) {
+ if (newSasHash[i] != 0) {
+ sasHashNull = false;
+ break;
+ }
+ }
+ // Check if new SAS is null or a trusted MitM relationship doesn't exist.
+ // If this is the case then don't render and don't show the new SAS - use
+ // the computed SAS hash but we may use a different SAS rendering algorithm to
+ // render the computed SAS.
+ if (sasHashNull || !peerIsEnrolled) {
+ newSasHash = sasHash;
+ }
+ // If other SAS schemes required - check here and use others
+ AlgorithmEnum* renderAlgo = &zrtpSasTypes.getByName((const char*)render);
+ uint8_t sasBytes[4];;
+ if (renderAlgo->isValid()) {
+ sasBytes[0] = newSasHash[0];
+ sasBytes[1] = newSasHash[1];
+ sasBytes[2] = newSasHash[2] & 0xf0;
+ sasBytes[3] = 0;
+ }
+ SAS = Base32(sasBytes, 20).getEncoded();
+ std::string cs(cipher->getReadable());
+ cs.append("/").append(pubKey->getName()).append("/MitM");
+
+ callback->srtpSecretsOn(cs, SAS, false);
+ return &zrtpRelayAck;
+}
+
+// TODO Implement GoClear handling
+ZrtpPacketClearAck* ZRtp::prepareClearAck(ZrtpPacketGoClear* gpkt) {
+ sendInfo(Warning, WarningGoClearReceived);
+ return &zrtpClearAck;
+}
+
+ZrtpPacketGoClear* ZRtp::prepareGoClear(uint32_t errMsg) {
+ ZrtpPacketGoClear* gclr = &zrtpGoClear;
+ gclr->clrClearHmac();
+ return gclr;
+}
+
+/*
+ * The next functions look up and return a prefered algorithm. These
+ * functions work as follows:
+ * - If the Hello packet does not contain an algorithm (number of algorithms
+* is zero) then return the mandatory algorithm.
+ * - Build a list of algorithm names and ids from configuration data. If
+ * the configuration data does not contain a mandatory algorithm append
+ * the mandatory algorithm to the list and ids.
+ * - Build a list of algorithm names from the Hello message. If
+ * the Hello message does not contain a mandatory algorithm append
+ * the mandatory algorithm to the list.
+ * - Lookup a matching algorithm. The list built from Hello takes
+ * precedence in the lookup (indexed by the outermost loop).
+ *
+ * This guarantees that we always return a supported alogrithm respecting
+ * the order of algorithms in the Hello message
+ *
+ * The mandatory algorithms are: (internal enums are our prefered algoritms)
+ * Hash: S256 (SHA 256) (internal enum Sha256)
+ * Symmetric Cipher: AES1 (AES 128) (internal enum Aes128)
+ * SRTP Authentication: HS32 and HS80 (32/80 bits) (internal enum AuthLen32)
+ * Key Agreement: DH3k (3072 Diffie-Helman) (internal enum Dh3072)
+ *
+ */
+AlgorithmEnum* ZRtp::findBestHash(ZrtpPacketHello *hello) {
+
+ int i;
+ int ii;
+ int numAlgosOffered;
+ AlgorithmEnum* algosOffered[ZrtpConfigure::maxNoOfAlgos+1];
+
+ int numAlgosConf;
+ AlgorithmEnum* algosConf[ZrtpConfigure::maxNoOfAlgos+1];
+
+ bool mandatoryFound = false;
+
+ // If Hello does not contain any hash names return Sha256, its mandatory
+ int num = hello->getNumHashes();
+ if (num == 0) {
+ return &zrtpHashes.getByName(mandatoryHash);
+ }
+ // Build list of configured hash algorithm names, append mandatory algos
+ // if necessary.
+ numAlgosConf = configureAlgos.getNumConfiguredAlgos(HashAlgorithm);
+ for (i = 0; i < numAlgosConf; i++) {
+ algosConf[i] = &configureAlgos.getAlgoAt(HashAlgorithm, i);
+ if (*(int32_t*)(algosConf[i]->getName()) == *(int32_t*)mandatoryHash) {
+ mandatoryFound = true;
+ }
+ }
+ if (!mandatoryFound) {
+ algosConf[numAlgosConf++] = &zrtpHashes.getByName(mandatoryHash);
+ }
+
+ // Build list of offered known algos in Hello, append mandatory algos if necessary
+ mandatoryFound = false;
+ for (numAlgosOffered = 0, i = 0; i < num; i++) {
+ algosOffered[numAlgosOffered] = &zrtpHashes.getByName((const char*)hello->getHashType(i));
+ if (!algosOffered[numAlgosOffered]->isValid())
+ continue;
+ if (*(int32_t*)(algosOffered[numAlgosOffered++]->getName()) == *(int32_t*)mandatoryHash) {
+ mandatoryFound = true;
+ }
+ }
+ if (!mandatoryFound) {
+ algosOffered[numAlgosOffered++] = &zrtpHashes.getByName(mandatoryHash);
+ }
+
+ // Lookup offered algos in configured algos. Because of appended
+ // mandatory algorithms at least one match will happen
+ for (i = 0; i < numAlgosOffered; i++) {
+ for (ii = 0; ii < numAlgosConf; ii++) {
+ if (*(int32_t*)(algosOffered[i]->getName()) == *(int32_t*)(algosConf[ii]->getName())) {
+ return algosConf[ii];
+ }
+ }
+ }
+ return &zrtpHashes.getByName(mandatoryHash);
+}
+
+AlgorithmEnum* ZRtp::findBestCipher(ZrtpPacketHello *hello, AlgorithmEnum* pk) {
+
+ int i;
+ int ii;
+ int numAlgosOffered;
+ AlgorithmEnum* algosOffered[ZrtpConfigure::maxNoOfAlgos+1];
+
+ int numAlgosConf;
+ AlgorithmEnum* algosConf[ZrtpConfigure::maxNoOfAlgos+1];
+
+ bool mandatoryFound = false;
+
+ int num = hello->getNumCiphers();
+ if (num == 0 || (*(int32_t*)(pk->getName()) == *(int32_t*)dh2k)) {
+ return &zrtpSymCiphers.getByName(aes1);
+ }
+
+ // Build list of configured cipher algorithm names, append mandatory algos
+ // if necessary.
+ numAlgosConf = configureAlgos.getNumConfiguredAlgos(CipherAlgorithm);
+ for (i = 0; i < numAlgosConf; i++) {
+ algosConf[i] = &configureAlgos.getAlgoAt(CipherAlgorithm, i);
+ if (*(int32_t*)(algosConf[i]->getName()) == *(int32_t*)mandatoryCipher) {
+ mandatoryFound = true;
+ }
+ }
+ if (!mandatoryFound) {
+ algosConf[numAlgosConf++] = &zrtpSymCiphers.getByName(mandatoryCipher);
+ }
+
+ // Build list of offered known algos names in Hello, append mandatory algos if
+ // necessary
+ mandatoryFound = false;
+ for (numAlgosOffered = 0, i = 0; i < num; i++) {
+ algosOffered[numAlgosOffered] = &zrtpSymCiphers.getByName((const char*)hello->getCipherType(i));
+ if (!algosOffered[numAlgosOffered]->isValid())
+ continue;
+ if (*(int32_t*)(algosOffered[numAlgosOffered++]->getName()) == *(int32_t*)mandatoryCipher) {
+ mandatoryFound = true;
+ }
+ }
+
+ if (!mandatoryFound) {
+ algosOffered[numAlgosOffered++] = &zrtpSymCiphers.getByName(mandatoryCipher);
+ }
+
+ // Lookup offered algos in configured algos. Because of appended
+ // mandatory algorithms at least one match will happen
+ for (i = 0; i < numAlgosOffered; i++) {
+ for (ii = 0; ii < numAlgosConf; ii++) {
+ if (*(int32_t*)(algosOffered[i]->getName()) == *(int32_t*)(algosConf[ii]->getName())) {
+ return algosConf[ii];
+ }
+ }
+ }
+ return &zrtpSymCiphers.getByName(mandatoryCipher);
+}
+
+AlgorithmEnum* ZRtp::findBestPubkey(ZrtpPacketHello *hello) {
+
+ int i;
+ int ii;
+ int numAlgosOffered;
+ AlgorithmEnum* algosOffered[ZrtpConfigure::maxNoOfAlgos+1];
+
+ int numAlgosConf;
+ AlgorithmEnum* algosConf[ZrtpConfigure::maxNoOfAlgos+1];
+
+ bool mandatoryFound = false;
+
+ int num = hello->getNumPubKeys();
+ if (num == 0) {
+ return &zrtpPubKeys.getByName(mandatoryPubKey);
+ }
+ // Build list of configured pubkey algorithm names, append mandatory algos
+ // if necessary.
+ // The list must include real public key algorithms only, so skip
+ // mult-stream mode, preshared and alike.
+ numAlgosConf = configureAlgos.getNumConfiguredAlgos(PubKeyAlgorithm);
+ for (i = 0, ii = 0; i < numAlgosConf; i++) {
+ algosConf[ii] = &configureAlgos.getAlgoAt(PubKeyAlgorithm, ii);
+ if (*(int32_t*)(algosConf[ii]->getName()) == *(int32_t*)mult) {
+ continue; // skip multi-stream mode
+ }
+ if (*(int32_t*)(algosConf[ii++]->getName()) == *(int32_t*)mandatoryPubKey) {
+ mandatoryFound = true;
+ }
+ }
+
+ numAlgosConf = ii;
+ if (!mandatoryFound) {
+ algosConf[numAlgosConf++] = &zrtpPubKeys.getByName(mandatoryPubKey);
+ }
+
+ // Build list of offered known algos in Hello, append mandatory algos if necessary
+ mandatoryFound = false;
+ for (numAlgosOffered = 0, i = 0; i < num; i++) {
+ algosOffered[numAlgosOffered] = &zrtpPubKeys.getByName((const char*)hello->getPubKeyType(i));
+ if (!algosOffered[numAlgosOffered]->isValid())
+ continue;
+ if (*(int32_t*)(algosOffered[numAlgosOffered++]->getName()) == *(int32_t*)mandatoryPubKey) {
+ mandatoryFound = true;
+ }
+ }
+
+ if (!mandatoryFound) {
+ algosOffered[numAlgosOffered++] = &zrtpPubKeys.getByName(mandatoryPubKey);
+ }
+
+ // Lookup offered algos in configured algos. Because of appended
+ // mandatory algorithms at least one match will happen
+ for (i = 0; i < numAlgosOffered; i++) {
+ for (ii = 0; ii < numAlgosConf; ii++) {
+ if (*(int32_t*)(algosOffered[i]->getName()) == *(int32_t*)(algosConf[ii]->getName())) {
+ return algosConf[ii];
+ }
+ }
+ }
+ return &zrtpPubKeys.getByName(mandatoryPubKey);
+}
+
+AlgorithmEnum* ZRtp::findBestSASType(ZrtpPacketHello *hello) {
+
+ int i;
+ int ii;
+ int numAlgosOffered;
+ AlgorithmEnum* algosOffered[ZrtpConfigure::maxNoOfAlgos+1];
+
+ int numAlgosConf;
+ AlgorithmEnum* algosConf[ZrtpConfigure::maxNoOfAlgos+1];
+
+ bool mandatoryFound = false;
+
+ int num = hello->getNumSas();
+ if (num == 0) {
+ return &zrtpSasTypes.getByName(mandatorySasType);
+ }
+ // Buildlist of configured SAS algorithm names, append mandatory algos
+ // if necessary.
+ numAlgosConf = configureAlgos.getNumConfiguredAlgos(SasType);
+ for (i = 0; i < numAlgosConf; i++) {
+ algosConf[i] = &configureAlgos.getAlgoAt(SasType, i);
+ if (*(int32_t*)(algosConf[i]->getName()) == *(int32_t*)mandatorySasType) {
+ mandatoryFound = true;
+ }
+ }
+
+ if (!mandatoryFound) {
+ algosConf[numAlgosConf++] = &zrtpSasTypes.getByName(mandatorySasType);
+ }
+
+ // Build list of offered known algos in Hello, append mandatory algos if necessary
+ for (numAlgosOffered = 0, i = 0; i < num; i++) {
+ algosOffered[numAlgosOffered] = &zrtpSasTypes.getByName((const char*)hello->getSasType(i));
+ if (!algosOffered[numAlgosOffered]->isValid())
+ continue;
+ if (*(int32_t*)(algosOffered[numAlgosOffered++]->getName()) == *(int32_t*)mandatorySasType) {
+ mandatoryFound = true;
+ }
+ }
+
+ if (!mandatoryFound) {
+ algosOffered[numAlgosOffered++] = &zrtpSasTypes.getByName(mandatorySasType);
+ }
+
+ // Lookup offered algos in configured algos. Because of appended
+ // mandatory algorithms at least one match will happen
+ for (i = 0; i < numAlgosOffered; i++) {
+ for (ii = 0; ii < numAlgosConf; ii++) {
+ if (*(int32_t*)(algosOffered[i]->getName()) == *(int32_t*)(algosConf[ii]->getName())) {
+ return algosConf[ii];
+ }
+ }
+ }
+ return &zrtpSasTypes.getByName(mandatorySasType);
+}
+
+AlgorithmEnum* ZRtp::findBestAuthLen(ZrtpPacketHello *hello) {
+
+ int i;
+ int ii;
+ int numAlgosOffered;
+ AlgorithmEnum* algosOffered[ZrtpConfigure::maxNoOfAlgos+2];
+
+ int numAlgosConf;
+ AlgorithmEnum* algosConf[ZrtpConfigure::maxNoOfAlgos+2];
+
+ bool mandatoryFound_1 = false;
+ bool mandatoryFound_2 = false;
+
+ int num = hello->getNumAuth();
+ if (num == 0) {
+ return &zrtpAuthLengths.getByName(mandatoryAuthLen_1);
+ }
+
+ // Build list of configured SAS algorithm names, append mandatory algos
+ // if necessary.
+ numAlgosConf = configureAlgos.getNumConfiguredAlgos(AuthLength);
+ for (i = 0; i < numAlgosConf; i++) {
+ algosConf[i] = &configureAlgos.getAlgoAt(AuthLength, i);
+ if (*(int32_t*)(algosConf[i]->getName()) == *(int32_t*)mandatoryAuthLen_1) {
+ mandatoryFound_1 = true;
+ }
+ if (*(int32_t*)(algosConf[i]->getName()) == *(int32_t*)mandatoryAuthLen_2) {
+ mandatoryFound_2 = true;
+ }
+ }
+
+ if (!mandatoryFound_1) {
+ algosConf[numAlgosConf++] = &zrtpAuthLengths.getByName(mandatoryAuthLen_1);
+ }
+
+ if (!mandatoryFound_2) {
+ algosConf[numAlgosConf++] = &zrtpAuthLengths.getByName(mandatoryAuthLen_2);
+ }
+
+ // Build list of offered known algos in Hello, append mandatory algos if necessary
+ for (numAlgosOffered = 0, i = 0; i < num; i++) {
+ algosOffered[numAlgosOffered] = &zrtpAuthLengths.getByName((const char*)hello->getAuthLen(i));
+ if (!algosOffered[numAlgosOffered]->isValid())
+ continue;
+ if (*(int32_t*)(algosOffered[numAlgosOffered]->getName()) == *(int32_t*)mandatoryAuthLen_1) {
+ mandatoryFound_1 = true;
+ }
+ if (*(int32_t*)(algosOffered[numAlgosOffered++]->getName()) == *(int32_t*)mandatoryAuthLen_2) {
+ mandatoryFound_2 = true;
+ }
+ }
+ if (!mandatoryFound_1) {
+ algosOffered[numAlgosOffered++] = &zrtpAuthLengths.getByName(mandatoryAuthLen_1);
+ }
+ if (!mandatoryFound_2) {
+ algosOffered[numAlgosOffered++] = &zrtpAuthLengths.getByName(mandatoryAuthLen_2);
+ }
+ // Lookup offered algos in configured algos. Because of appended
+ // mandatory algorithms at least one match will happen
+ for (i = 0; i < numAlgosOffered; i++) {
+ for (ii = 0; ii < numAlgosConf; ii++) {
+ if (*(int32_t*)(algosOffered[i]->getName()) == *(int32_t*)(algosConf[ii]->getName())) {
+ return algosConf[ii];
+ }
+ }
+ }
+ return &zrtpAuthLengths.getByName(mandatoryAuthLen_1);
+}
+
+bool ZRtp::checkMultiStream(ZrtpPacketHello *hello) {
+
+ int i;
+ int num = hello->getNumPubKeys();
+
+ // Multi Stream mode is mandatory, thus if nothing is offered then it is supported :-)
+ if (num == 0) {
+ return true;
+ }
+ for (i = 0; i < num; i++) {
+ if (*(int32_t*)(hello->getPubKeyType(i)) == *(int32_t*)mult) {
+ return true;
+ }
+ }
+ return false;
+}
+
+bool ZRtp::verifyH2(ZrtpPacketCommit *commit) {
+ uint8_t tmpH3[IMPL_MAX_DIGEST_LENGTH];
+
+ sha256(commit->getH2(), HASH_IMAGE_SIZE, tmpH3);
+ if (memcmp(tmpH3, peerH3, HASH_IMAGE_SIZE) != 0) {
+ return false;
+ }
+ return true;
+}
+
+void ZRtp::computeHvi(ZrtpPacketDHPart* dh, ZrtpPacketHello *hello) {
+
+ unsigned char* data[3];
+ unsigned int length[3];
+ /*
+ * populate the vector to compute the HVI hash according to the
+ * ZRTP specification.
+ */
+ data[0] = (uint8_t*)dh->getHeaderBase();
+ length[0] = dh->getLength() * ZRTP_WORD_SIZE;
+
+ data[1] = (uint8_t*)hello->getHeaderBase();
+ length[1] = hello->getLength() * ZRTP_WORD_SIZE;
+
+ data[2] = NULL; // terminate data chunks
+ hashListFunction(data, length, hvi);
+ return;
+}
+
+void ZRtp:: computeSharedSecretSet(ZIDRecord &zidRec) {
+
+ /*
+ * Compute the Initiator's and Reponder's retained shared secret Ids.
+ * Use negotiated HMAC.
+ */
+ uint8_t randBuf[RS_LENGTH];
+ uint32_t macLen;
+
+ if (!zidRec.isRs1Valid()) {
+ randomZRTP(randBuf, RS_LENGTH);
+ hmacFunction(randBuf, RS_LENGTH, (unsigned char*)initiator, strlen(initiator), rs1IDi, &macLen);
+ hmacFunction(randBuf, RS_LENGTH, (unsigned char*)responder, strlen(responder), rs1IDr, &macLen);
+ }
+ else {
+ rs1Valid = true;
+ hmacFunction((unsigned char*)zidRec.getRs1(), RS_LENGTH, (unsigned char*)initiator, strlen(initiator), rs1IDi, &macLen);
+ hmacFunction((unsigned char*)zidRec.getRs1(), RS_LENGTH, (unsigned char*)responder, strlen(responder), rs1IDr, &macLen);
+ }
+
+ if (!zidRec.isRs2Valid()) {
+ randomZRTP(randBuf, RS_LENGTH);
+ hmacFunction(randBuf, RS_LENGTH, (unsigned char*)initiator, strlen(initiator), rs2IDi, &macLen);
+ hmacFunction(randBuf, RS_LENGTH, (unsigned char*)responder, strlen(responder), rs2IDr, &macLen);
+ }
+ else {
+ rs2Valid = true;
+ hmacFunction((unsigned char*)zidRec.getRs2(), RS_LENGTH, (unsigned char*)initiator, strlen(initiator), rs2IDi, &macLen);
+ hmacFunction((unsigned char*)zidRec.getRs2(), RS_LENGTH, (unsigned char*)responder, strlen(responder), rs2IDr, &macLen);
+ }
+
+ /*
+ * For the time being we don't support this types of shared secrect. Could be
+ * easily done: somebody sets some data into our ZRtp object, check it here
+ * and use it. Otherwise use the random data.
+ */
+ randomZRTP(randBuf, RS_LENGTH);
+ hmacFunction(randBuf, RS_LENGTH, (unsigned char*)initiator, strlen(initiator), auxSecretIDi, &macLen);
+ hmacFunction(randBuf, RS_LENGTH, (unsigned char*)responder, strlen(responder), auxSecretIDr, &macLen);
+
+ if (!zidRec.isMITMKeyAvailable()) {
+ randomZRTP(randBuf, RS_LENGTH);
+ hmacFunction(randBuf, RS_LENGTH, (unsigned char*)initiator, strlen(initiator), pbxSecretIDi, &macLen);
+ hmacFunction(randBuf, RS_LENGTH, (unsigned char*)responder, strlen(responder), pbxSecretIDr, &macLen);
+ }
+ else {
+ hmacFunction((unsigned char*)zidRec.getMiTMData(), RS_LENGTH, (unsigned char*)initiator, strlen(initiator), pbxSecretIDi, &macLen);
+ hmacFunction((unsigned char*)zidRec.getMiTMData(), RS_LENGTH, (unsigned char*)responder, strlen(responder), pbxSecretIDr, &macLen);
+ }
+}
+
+/*
+ * The DH packet for this function is DHPart1 and contains the Responder's
+ * retained secret ids. Compare them with the expected secret ids (refer
+ * to chapter 5.3 in the specification).
+ * When using this method then we are in Initiator role.
+ */
+void ZRtp::generateKeysInitiator(ZrtpPacketDHPart *dhPart, ZIDRecord& zidRec) {
+ const uint8_t* setD[3];
+ int32_t rsFound = 0;
+
+ setD[0] = setD[1] = setD[2] = NULL;
+
+ /*
+ * Select the real secrets into setD. The dhPart is DHpart1 message
+ * received from responder. rs1IDr and rs2IDr are the expected ids using
+ * the initator's cached retained secrets.
+ */
+ int matchingSecrets = 0;
+ if (memcmp(rs1IDr, dhPart->getRs1Id(), HMAC_SIZE) == 0) {
+ setD[matchingSecrets++] = zidRec.getRs1();
+ rsFound = 0x1;
+ }
+ else if (memcmp(rs1IDr, dhPart->getRs2Id(), HMAC_SIZE) == 0) {
+ setD[matchingSecrets++] = zidRec.getRs1();
+ rsFound = 0x2;
+ }
+ else if (memcmp(rs2IDr, dhPart->getRs1Id(), HMAC_SIZE) == 0) {
+ setD[matchingSecrets++] = zidRec.getRs2();
+ rsFound = 0x4;
+ }
+ else if (memcmp(rs2IDr, dhPart->getRs2Id(), HMAC_SIZE) == 0) {
+ setD[matchingSecrets++] = zidRec.getRs2();
+ rsFound = 0x8;
+ }
+ /* *** Not yet supported
+ if (memcmp(auxSecretIDr, dhPart->getAuxSecretId(), 8) == 0) {
+ DEBUGOUT((fprintf(stdout, "%c: Match for aux secret found\n", zid[0])));
+ setD[matchingSecrets++] = auxSecret;
+ }
+ */
+ if (memcmp(pbxSecretIDr, dhPart->getPbxSecretId(), 8) == 0) {
+ DEBUGOUT((fprintf(stdout, "%c: Match for Other_secret found\n", zid[0])));
+ setD[matchingSecrets++] = zidRec.getMiTMData();
+ }
+ // Check if some retained secrets found
+ if (rsFound == 0) { // no RS matches found
+ if (rs1Valid || rs2Valid) { // but valid RS records in cache
+ sendInfo(Warning, WarningNoExpectedRSMatch);
+ zidRec.resetSasVerified();
+ }
+ else { // No valid RS record in cache
+ sendInfo(Warning, WarningNoRSMatch);
+ }
+ }
+ else { // at least one RS matches
+ sendInfo(Info, InfoRSMatchFound);
+ }
+ /*
+ * Ready to generate s0 here.
+ * The formular to compute S0 (Refer to ZRTP specification 5.4.4):
+ *
+ s0 = hash( counter | DHResult | "ZRTP-HMAC-KDF" | ZIDi | ZIDr | \
+ total_hash | len(s1) | s1 | len(s2) | s2 | len(s3) | s3)
+ *
+ * Note: in this function we are Initiator, thus ZIDi is our zid
+ * (zid), ZIDr is the peer's zid (peerZid).
+ */
+
+ /*
+ * These arrays hold the pointers and lengths of the data that must be
+ * hashed to create S0. According to the formula the max number of
+ * elements to hash is 12, add one for the terminating "NULL"
+ */
+ unsigned char* data[13];
+ unsigned int length[13];
+ uint32_t pos = 0; // index into the array
+
+ // we need a number of length data items, so define them here
+ uint32_t counter, sLen[3];
+
+ //Very first element is a fixed counter, big endian
+ counter = 1;
+ counter = htonl(counter);
+ data[pos] = (unsigned char*)&counter;
+ length[pos++] = sizeof(uint32_t);
+
+ // Next is the DH result itself
+ data[pos] = DHss;
+ length[pos++] = dhContext->getDhSize();
+
+ // Next the fixed string "ZRTP-HMAC-KDF"
+ data[pos] = (unsigned char*)KDFString;
+ length[pos++] = strlen(KDFString);
+
+ // Next is Initiator's id (ZIDi), in this case as Initiator
+ // it is zid
+ data[pos] = zid;
+ length[pos++] = ZID_SIZE;
+
+ // Next is Responder's id (ZIDr), in this case our peer's id
+ data[pos] = peerZid;
+ length[pos++] = ZID_SIZE;
+
+ // Next ist total hash (messageHash) itself
+ data[pos] = messageHash;
+ length[pos++] = hashLength;
+
+ /*
+ * For each matching shared secret hash the length of
+ * the shared secret as 32 bit big-endian number followd by the
+ * shared secret itself. The length of a shared seceret is
+ * currently fixed to RS_LENGTH. If a shared
+ * secret is not used _only_ its length is hased as zero
+ * length. NOTE: if implementing auxSecret and/or pbxSecret -> check
+ * this length stuff again.
+ */
+ int secretHashLen = RS_LENGTH;
+ secretHashLen = htonl(secretHashLen); // prepare 32 bit big-endian number
+
+ for (int32_t i = 0; i < 3; i++) {
+ if (setD[i] != NULL) { // a matching secret, set length, then secret
+ sLen[i] = secretHashLen;
+ data[pos] = (unsigned char*)&sLen[i];
+ length[pos++] = sizeof(uint32_t);
+ data[pos] = (unsigned char*)setD[i];
+ length[pos++] = RS_LENGTH;
+ }
+ else { // no machting secret, set length 0, skip secret
+ sLen[i] = 0;
+ data[pos] = (unsigned char*)&sLen[i];
+ length[pos++] = sizeof(uint32_t);
+ }
+ }
+
+ data[pos] = NULL;
+ hashListFunction(data, length, s0);
+// hexdump("S0 I", s0, hashLength);
+
+ memset(DHss, 0, dhContext->getDhSize());
+ delete[] DHss;
+ DHss = NULL;
+
+ computeSRTPKeys();
+ memset(s0, 0, MAX_DIGEST_LENGTH);
+}
+/*
+ * The DH packet for this function is DHPart2 and contains the Initiator's
+ * retained secret ids. Compare them with the expected secret ids (refer
+ * to chapter 5.3.1 in the specification).
+ */
+void ZRtp::generateKeysResponder(ZrtpPacketDHPart *dhPart, ZIDRecord& zidRec) {
+ const uint8_t* setD[3];
+ int32_t rsFound = 0;
+
+ setD[0] = setD[1] = setD[2] = NULL;
+
+ /*
+ * Select the real secrets into setD
+ */
+ int matchingSecrets = 0;
+ if (memcmp(rs1IDi, dhPart->getRs1Id(), HMAC_SIZE) == 0) {
+ setD[matchingSecrets++] = zidRec.getRs1();
+ rsFound = 0x1;
+ }
+ else if (memcmp(rs1IDi, dhPart->getRs2Id(), HMAC_SIZE) == 0) {
+ setD[matchingSecrets++] = zidRec.getRs1();
+ rsFound = 0x2;
+ }
+ else if (memcmp(rs2IDi, dhPart->getRs2Id(), HMAC_SIZE) == 0) {
+ setD[matchingSecrets++] = zidRec.getRs2();
+ rsFound |= 0x4;
+ }
+ else if (memcmp(rs2IDi, dhPart->getRs1Id(), HMAC_SIZE) == 0) {
+ setD[matchingSecrets++] = zidRec.getRs2();
+ rsFound |= 0x8;
+ }
+ /* ***** not yet supported
+ if (memcmp(auxSecretIDi, dhPart->getauxSecretId(), 8) == 0) {
+ DEBUGOUT((fprintf(stdout, "%c: Match for aux secret found\n", zid[0])));
+ setD[matchingSecrets++] = ;
+ }
+ */
+ if (memcmp(pbxSecretIDi, dhPart->getPbxSecretId(), 8) == 0) {
+ DEBUGOUT((fprintf(stdout, "%c: Match for PBX secret found\n", zid[0])));
+ setD[matchingSecrets++] = zidRec.getMiTMData();
+ }
+ // Check if some retained secrets found
+ if (rsFound == 0) { // no RS matches found
+ if (rs1Valid || rs2Valid) { // but valid RS records in cache
+ sendInfo(Warning, WarningNoExpectedRSMatch);
+ zidRec.resetSasVerified();
+ }
+ else { // No valid RS record in cache
+ sendInfo(Warning, WarningNoRSMatch);
+ }
+ }
+ else { // at least one RS matches
+ sendInfo(Info, InfoRSMatchFound);
+ }
+
+ /*
+ * ready to generate s0 here.
+ * The formular to compute S0 (Refer to ZRTP specification 5.4.4):
+ *
+ s0 = hash( counter | DHResult | "ZRTP-HMAC-KDF" | ZIDi | ZIDr | \
+ total_hash | len(s1) | s1 | len(s2) | s2 | len(s3) | s3)
+ *
+ * Note: in this function we are Responder, thus ZIDi is the peer's zid
+ * (peerZid), ZIDr is our zid.
+ */
+
+ /*
+ * These arrays hold the pointers and lengths of the data that must be
+ * hashed to create S0. According to the formula the max number of
+ * elements to hash is 12, add one for the terminating "NULL"
+ */
+ unsigned char* data[13];
+ unsigned int length[13];
+ uint32_t pos = 0; // index into the array
+
+
+ // we need a number of length data items, so define them here
+ uint32_t counter, sLen[3];
+
+ //Very first element is a fixed counter, big endian
+ counter = 1;
+ counter = htonl(counter);
+ data[pos] = (unsigned char*)&counter;
+ length[pos++] = sizeof(uint32_t);
+
+ // Next is the DH result itself
+ data[pos] = DHss;
+ length[pos++] = dhContext->getDhSize();
+
+ // Next the fixed string "ZRTP-HMAC-KDF"
+ data[pos] = (unsigned char*)KDFString;
+ length[pos++] = strlen(KDFString);
+
+ // Next is Initiator's id (ZIDi), in this case as Responder
+ // it is peerZid
+ data[pos] = peerZid;
+ length[pos++] = ZID_SIZE;
+
+ // Next is Responder's id (ZIDr), in this case our own zid
+ data[pos] = zid;
+ length[pos++] = ZID_SIZE;
+
+ // Next ist total hash (messageHash) itself
+ data[pos] = messageHash;
+ length[pos++] = hashLength;
+
+ /*
+ * For each matching shared secret hash the length of
+ * the shared secret as 32 bit big-endian number followd by the
+ * shared secret itself. The length of a shared seceret is
+ * currently fixed to SHA256_DIGEST_LENGTH. If a shared
+ * secret is not used _only_ its length is hased as zero
+ * length. NOTE: if implementing auxSecret and/or pbxSecret -> check
+ * this length stuff again.
+ */
+ int secretHashLen = RS_LENGTH;
+ secretHashLen = htonl(secretHashLen); // prepare 32 bit big-endian number
+
+ for (int32_t i = 0; i < 3; i++) {
+ if (setD[i] != NULL) { // a matching secret, set length, then secret
+ sLen[i] = secretHashLen;
+ data[pos] = (unsigned char*)&sLen[i];
+ length[pos++] = sizeof(uint32_t);
+ data[pos] = (unsigned char*)setD[i];
+ length[pos++] = RS_LENGTH;
+ }
+ else { // no machting secret, set length 0, skip secret
+ sLen[i] = 0;
+ data[pos] = (unsigned char*)&sLen[i];
+ length[pos++] = sizeof(uint32_t);
+ }
+ }
+
+ data[pos] = NULL;
+ hashListFunction(data, length, s0);
+// hexdump("S0 R", s0, hashLength);
+
+ memset(DHss, 0, dhContext->getDhSize());
+ delete[] DHss;
+ DHss = NULL;
+
+ computeSRTPKeys();
+ memset(s0, 0, MAX_DIGEST_LENGTH);
+}
+
+
+void ZRtp::KDF(uint8_t* key, uint32_t keyLength, uint8_t* label, int32_t labelLength,
+ uint8_t* context, int32_t contextLength, int32_t L, uint8_t* output) {
+
+ unsigned char* data[6];
+ uint32_t length[6];
+ uint32_t pos = 0; // index into the array
+ uint32_t maclen = 0;
+
+ // Very first element is a fixed counter, big endian
+ uint32_t counter = 1;
+ counter = htonl(counter);
+ data[pos] = (unsigned char*)&counter;
+ length[pos++] = sizeof(uint32_t);
+
+ // Next element is the label, null terminated, labelLength includes null byte.
+ data[pos] = label;
+ length[pos++] = labelLength;
+
+ // Next is the KDF context
+ data[pos] = context;
+ length[pos++] = contextLength;
+
+ // last element is HMAC length in bits, big endian
+ uint32_t len = htonl(L);
+ data[pos] = (unsigned char*)&len;
+ length[pos++] = sizeof(uint32_t);
+
+ data[pos] = NULL;
+
+ // Use negotiated hash.
+ hmacListFunction(key, keyLength, data, length, output, &maclen);
+}
+
+// Compute the Multi Stream mode s0
+void ZRtp::generateKeysMultiStream() {
+
+ // allocate the maximum size, compute real size to use
+ uint8_t KDFcontext[sizeof(peerZid)+sizeof(zid)+sizeof(messageHash)];
+ int32_t kdfSize = sizeof(peerZid)+sizeof(zid)+hashLength;
+
+ if (myRole == Responder) {
+ memcpy(KDFcontext, peerZid, sizeof(peerZid));
+ memcpy(KDFcontext+sizeof(peerZid), zid, sizeof(zid));
+ }
+ else {
+ memcpy(KDFcontext, zid, sizeof(zid));
+ memcpy(KDFcontext+sizeof(zid), peerZid, sizeof(peerZid));
+ }
+ memcpy(KDFcontext+sizeof(zid)+sizeof(peerZid), messageHash, hashLength);
+
+ KDF(zrtpSession, hashLength, (unsigned char*)zrtpMsk, strlen(zrtpMsk)+1, KDFcontext, kdfSize, hashLength*8, s0);
+
+ memset(KDFcontext, 0, sizeof(KDFcontext));
+
+ computeSRTPKeys();
+}
+
+void ZRtp::computePBXSecret() {
+ // Construct the KDF context as per ZRTP specification chap 7.3.1:
+ // ZIDi || ZIDr
+ uint8_t KDFcontext[sizeof(peerZid)+sizeof(zid)];
+ int32_t kdfSize = sizeof(peerZid)+sizeof(zid);
+
+ if (myRole == Responder) {
+ memcpy(KDFcontext, peerZid, sizeof(peerZid));
+ memcpy(KDFcontext+sizeof(peerZid), zid, sizeof(zid));
+ }
+ else {
+ memcpy(KDFcontext, zid, sizeof(zid));
+ memcpy(KDFcontext+sizeof(zid), peerZid, sizeof(peerZid));
+ }
+
+ KDF(zrtpSession, hashLength, (unsigned char*)zrtpTrustedMitm, strlen(zrtpTrustedMitm)+1, KDFcontext,
+ kdfSize, SHA256_DIGEST_LENGTH * 8, pbxSecretTmpBuffer);
+
+ pbxSecretTmp = pbxSecretTmpBuffer; // set pointer to buffer, signal PBX secret was computed
+}
+
+
+void ZRtp::computeSRTPKeys() {
+
+ // allocate the maximum size, compute real size to use
+ uint8_t KDFcontext[sizeof(peerZid)+sizeof(zid)+sizeof(messageHash)];
+ int32_t kdfSize = sizeof(peerZid)+sizeof(zid)+hashLength;
+
+ int32_t keyLen = cipher->getKeylen() * 8;
+
+ if (myRole == Responder) {
+ memcpy(KDFcontext, peerZid, sizeof(peerZid));
+ memcpy(KDFcontext+sizeof(peerZid), zid, sizeof(zid));
+ }
+ else {
+ memcpy(KDFcontext, zid, sizeof(zid));
+ memcpy(KDFcontext+sizeof(zid), peerZid, sizeof(peerZid));
+ }
+ memcpy(KDFcontext+sizeof(zid)+sizeof(peerZid), messageHash, hashLength);
+
+ // Inititiator key and salt
+ KDF(s0, hashLength, (unsigned char*)iniMasterKey, strlen(iniMasterKey)+1, KDFcontext, kdfSize, keyLen, srtpKeyI);
+ KDF(s0, hashLength, (unsigned char*)iniMasterSalt, strlen(iniMasterSalt)+1, KDFcontext, kdfSize, 112, srtpSaltI);
+
+ // Responder key and salt
+ KDF(s0, hashLength, (unsigned char*)respMasterKey, strlen(respMasterKey)+1, KDFcontext, kdfSize, keyLen, srtpKeyR);
+ KDF(s0, hashLength, (unsigned char*)respMasterSalt, strlen(respMasterSalt)+1, KDFcontext, kdfSize, 112, srtpSaltR);
+
+ // The HMAC keys for GoClear
+ KDF(s0, hashLength, (unsigned char*)iniHmacKey, strlen(iniHmacKey)+1, KDFcontext, kdfSize, hashLength*8, hmacKeyI);
+
+ KDF(s0, hashLength, (unsigned char*)respHmacKey, strlen(respHmacKey)+1, KDFcontext, kdfSize, hashLength*8, hmacKeyR);
+
+ // The keys for Confirm messages
+ KDF(s0, hashLength, (unsigned char*)iniZrtpKey, strlen(iniZrtpKey)+1, KDFcontext, kdfSize, keyLen, zrtpKeyI);
+ KDF(s0, hashLength, (unsigned char*)respZrtpKey, strlen(respZrtpKey)+1, KDFcontext, kdfSize, keyLen, zrtpKeyR);
+
+ if (!multiStream) {
+ // Compute the new Retained Secret
+ KDF(s0, hashLength, (unsigned char*)retainedSec, strlen(retainedSec)+1, KDFcontext, kdfSize, SHA256_DIGEST_LENGTH*8, newRs1);
+
+ // Compute the ZRTP Session Key
+ KDF(s0, hashLength, (unsigned char*)zrtpSessionKey, strlen(zrtpSessionKey)+1, KDFcontext, kdfSize, hashLength*8, zrtpSession);
+
+ // perform SAS generation according to chapter 5.5 and 8.
+ // we don't need a speciai sasValue filed. sasValue are the first
+ // (leftmost) 32 bits (4 bytes) of sasHash
+ uint8_t sasBytes[4];
+ KDF(s0, hashLength, (unsigned char*)sasString, strlen(sasString)+1, KDFcontext, kdfSize, SHA256_DIGEST_LENGTH*8, sasHash);
+
+ // according to chapter 8 only the leftmost 20 bits of sasValue (aka
+ // sasHash) are used to create the character SAS string of type SAS
+ // base 32 (5 bits per character)
+ sasBytes[0] = sasHash[0];
+ sasBytes[1] = sasHash[1];
+ sasBytes[2] = sasHash[2] & 0xf0;
+ sasBytes[3] = 0;
+ SAS = Base32(sasBytes, 20).getEncoded();
+ if (signSasSeen)
+ callback->signSAS(sasHash);
+ }
+ memset(KDFcontext, 0, sizeof(KDFcontext));
+}
+
+bool ZRtp::srtpSecretsReady(EnableSecurity part) {
+
+ SrtpSecret_t sec;
+
+ sec.symEncAlgorithm = cipher->getAlgoId();
+
+ sec.keyInitiator = srtpKeyI;
+ sec.initKeyLen = cipher->getKeylen() * 8;
+ sec.saltInitiator = srtpSaltI;
+ sec.initSaltLen = 112;
+
+ sec.keyResponder = srtpKeyR;
+ sec.respKeyLen = cipher->getKeylen() * 8;
+ sec.saltResponder = srtpSaltR;
+ sec.respSaltLen = 112;
+
+ sec.authAlgorithm = authLength->getAlgoId();
+ sec.srtpAuthTagLen = authLength->getKeylen();
+
+ sec.sas = SAS;
+ sec.role = myRole;
+
+ return callback->srtpSecretsReady(&sec, part);
+}
+
+
+void ZRtp::setNegotiatedHash(AlgorithmEnum* hash) {
+ switch (zrtpHashes.getOrdinal(*hash)) {
+ case 0:
+ hashLength = SHA256_DIGEST_LENGTH;
+ hashFunction = sha256;
+ hashListFunction = sha256;
+
+ hmacFunction = hmac_sha256;
+ hmacListFunction = hmac_sha256;
+
+ createHashCtx = createSha256Context;
+ closeHashCtx = closeSha256Context;
+ hashCtxFunction = sha256Ctx;
+ hashCtxListFunction = sha256Ctx;
+ break;
+
+ case 1:
+ hashLength = SHA384_DIGEST_LENGTH;
+ hashFunction = sha384;
+ hashListFunction = sha384;
+
+ hmacFunction = hmac_sha384;
+ hmacListFunction = hmac_sha384;
+
+ createHashCtx = createSha384Context;
+ closeHashCtx = closeSha384Context;
+ hashCtxFunction = sha384Ctx;
+ hashCtxListFunction = sha384Ctx;
+ break;
+ }
+}
+
+
+void ZRtp::srtpSecretsOff(EnableSecurity part) {
+ callback->srtpSecretsOff(part);
+}
+
+void ZRtp::SASVerified() {
+ if (paranoidMode)
+ return;
+
+ // Initialize a ZID record to get peer's retained secrets
+ ZIDRecord zidRec(peerZid);
+ ZIDFile *zid = ZIDFile::getInstance();
+
+ zid->getRecord(&zidRec);
+ zidRec.setSasVerified();
+ zid->saveRecord(&zidRec);
+}
+
+void ZRtp::resetSASVerified() {
+ // Initialize a ZID record to get peer's retained secrets
+ ZIDRecord zidRec(peerZid);
+ ZIDFile *zid = ZIDFile::getInstance();
+
+ zid->getRecord(&zidRec);
+ zidRec.resetSasVerified();
+ zid->saveRecord(&zidRec);
+}
+
+
+void ZRtp::sendInfo(GnuZrtpCodes::MessageSeverity severity, int32_t subCode) {
+
+ // We've reached secure state: overwrite the SRTP master key and master salt.
+ if (severity == Info && subCode == InfoSecureStateOn) {
+ memset(srtpKeyI, 0, cipher->getKeylen());
+ memset(srtpSaltI, 0, 112/8);
+ memset(srtpKeyR, 0, cipher->getKeylen());
+ memset(srtpSaltR, 0, 112/8);
+ }
+ callback->sendInfo(severity, subCode);
+}
+
+
+void ZRtp::zrtpNegotiationFailed(GnuZrtpCodes::MessageSeverity severity, int32_t subCode) {
+ callback->zrtpNegotiationFailed(severity, subCode);
+}
+
+void ZRtp::zrtpNotSuppOther() {
+ callback->zrtpNotSuppOther();
+}
+
+void ZRtp::synchEnter() {
+ callback->synchEnter();
+}
+
+void ZRtp::synchLeave() {
+ callback->synchLeave();
+}
+
+int32_t ZRtp::sendPacketZRTP(ZrtpPacketBase *packet) {
+ return ((packet == NULL) ? 0 :
+ callback->sendDataZRTP(packet->getHeaderBase(), (packet->getLength() * 4) + 4));
+}
+
+int32_t ZRtp::activateTimer(int32_t tm) {
+ return (callback->activateTimer(tm));
+}
+
+int32_t ZRtp::cancelTimer() {
+ return (callback->cancelTimer());
+}
+
+void ZRtp::setAuxSecret(uint8_t* data, int32_t length) {
+ if (length > 0) {
+ auxSecret = new uint8_t[length];
+ auxSecretLength = length;
+ memcpy(auxSecret, data, length);
+ }
+}
+
+void ZRtp::setClientId(std::string id) {
+ if (id.size() < CLIENT_ID_SIZE) {
+ unsigned char tmp[CLIENT_ID_SIZE +1] = {' '};
+ memcpy(tmp, id.c_str(), id.size());
+ tmp[CLIENT_ID_SIZE] = 0;
+ zrtpHello.setClientId(tmp);
+ } else {
+ zrtpHello.setClientId((unsigned char*)id.c_str());
+ }
+
+ int32_t len = zrtpHello.getLength() * ZRTP_WORD_SIZE;
+
+ // Hello packet is ready now, compute its HMAC
+ // (excluding the HMAC field (2*ZTP_WORD_SIZE)) and store in Hello
+ // use the implicit hash function
+ uint8_t hmac[IMPL_MAX_DIGEST_LENGTH];
+ uint32_t macLen;
+ hmacFunctionImpl(H2, HASH_IMAGE_SIZE, (uint8_t*)zrtpHello.getHeaderBase(), len-(2*ZRTP_WORD_SIZE), hmac, &macLen);
+ zrtpHello.setHMAC(hmac);
+
+ // calculate hash over the final Hello packet, refer to chap 9.1 how to
+ // use this hash in SIP/SDP.
+ hashFunctionImpl((uint8_t*)zrtpHello.getHeaderBase(), len, helloHash);
+}
+
+void ZRtp::storeMsgTemp(ZrtpPacketBase* pkt) {
+ uint32_t length = pkt->getLength() * ZRTP_WORD_SIZE;
+ length = (length > sizeof(tempMsgBuffer)) ? sizeof(tempMsgBuffer) : length;
+ memset(tempMsgBuffer, 0, sizeof(tempMsgBuffer));
+ memcpy(tempMsgBuffer, (uint8_t*)pkt->getHeaderBase(), length);
+ lengthOfMsgData = length;
+}
+
+bool ZRtp::checkMsgHmac(uint8_t* key) {
+ uint8_t hmac[IMPL_MAX_DIGEST_LENGTH];
+ uint32_t macLen;
+ int32_t len = lengthOfMsgData-(HMAC_SIZE); // compute HMAC, but exlude the stored HMAC :-)
+
+ // Use the implicit hash function
+ hmacFunctionImpl(key, HASH_IMAGE_SIZE, tempMsgBuffer, len, hmac, &macLen);
+ return (memcmp(hmac, tempMsgBuffer+len, (HMAC_SIZE)) == 0 ? true : false);
+}
+
+std::string ZRtp::getHelloHash() {
+ std::ostringstream stm;
+
+ uint8_t* hp = helloHash;
+
+ stm << zrtpVersion;
+ stm << " ";
+ stm.fill('0');
+ stm << hex;
+ for (int i = 0; i < hashLengthImpl; i++) {
+ stm.width(2);
+ stm << static_cast<uint32_t>(*hp++);
+ }
+ return stm.str();
+}
+
+std::string ZRtp::getPeerHelloHash() {
+ std::ostringstream stm;
+
+ if (peerHelloVersion[0] == 0)
+ return std::string();
+
+ uint8_t* hp = peerHelloHash;
+
+ stm << peerHelloVersion;
+ stm << " ";
+ stm.fill('0');
+ stm << hex;
+ for (int i = 0; i < hashLengthImpl; i++) {
+ stm.width(2);
+ stm << static_cast<uint32_t>(*hp++);
+ }
+ return stm.str();
+}
+
+std::string ZRtp::getMultiStrParams() {
+
+ // the string will hold binary data - it's opaque to the application
+ std::string str("");
+ char tmp[MAX_DIGEST_LENGTH + 1 + 1 + 1]; // hash length + cipher + authLength + hash
+
+ if (inState(SecureState) && !multiStream) {
+ // construct array that holds zrtpSession, cipher type, auth-length, and hash type
+ tmp[0] = zrtpHashes.getOrdinal(*hash);
+ tmp[1] = zrtpAuthLengths.getOrdinal(*authLength);
+ tmp[2] = zrtpSymCiphers.getOrdinal(*cipher);
+ memcpy(tmp+3, zrtpSession, hashLength);
+ str.assign(tmp, hashLength + 1 + 1 + 1); // set chars (bytes) to the string
+ }
+ return str;
+}
+
+void ZRtp::setMultiStrParams(std::string parameters) {
+
+ char tmp[MAX_DIGEST_LENGTH + 1 + 1 + 1]; // max. hash length + cipher + authLength + hash
+
+ // First get negotiated hash from parameters, set algorithms and length
+ int i = parameters.at(0) & 0xff;
+ hash = &zrtpHashes.getByOrdinal(i);
+ setNegotiatedHash(hash); // sets hashlength
+
+ // use string.copy(buffer, num, start=0) to retrieve chars (bytes) from the string
+ parameters.copy(tmp, hashLength + 1 + 1 + 1, 0);
+
+ i = tmp[1] & 0xff;
+ authLength = &zrtpAuthLengths.getByOrdinal(i);
+ i = tmp[2] & 0xff;
+ cipher = &zrtpSymCiphers.getByOrdinal(i);
+ memcpy(zrtpSession, tmp+3, hashLength);
+
+ // after setting zrtpSession, cipher, and auth-length set multi-stream to true
+ multiStream = true;
+ stateEngine->setMultiStream(true);
+}
+
+bool ZRtp::isMultiStream() {
+ return multiStream;
+}
+
+bool ZRtp::isMultiStreamAvailable() {
+ return multiStreamAvailable;
+}
+
+void ZRtp::acceptEnrollment(bool accepted) {
+ if (!accepted) {
+ callback->zrtpInformEnrollment(EnrollmentCanceled);
+ return;
+ }
+ // Get peer's zid record to store the pbx (MitM) secret
+ // Initialize a ZID record to get peer's retained secrets
+ ZIDRecord zidRec(peerZid);
+ ZIDFile* zid = ZIDFile::getInstance();
+ zid->getRecord(&zidRec);
+
+ if (pbxSecretTmp != NULL) {
+ zidRec.setMiTMData(pbxSecretTmp);
+ callback->zrtpInformEnrollment(EnrollmentOk);
+ }
+ else {
+ callback->zrtpInformEnrollment(EnrollmentFailed);
+ return;
+ }
+ zid->saveRecord(&zidRec);
+ return;
+}
+
+bool ZRtp::setSignatureData(uint8_t* data, int32_t length) {
+ if ((length % 4) != 0)
+ return false;
+
+ ZrtpPacketConfirm* cfrm = (myRole == Responder) ? &zrtpConfirm1 : &zrtpConfirm2;
+ cfrm->setSignatureLength(length / 4);
+ return cfrm->setSignatureData(data, length);
+}
+
+const uint8_t* ZRtp::getSignatureData() {
+ return signatureData;
+}
+
+int32_t ZRtp::getSignatureLength() {
+ return signatureLength * ZRTP_WORD_SIZE;
+}
+
+void ZRtp::conf2AckSecure() {
+ Event_t ev;
+
+ ev.type = ZrtpPacket;
+ ev.packet = (uint8_t*)&zrtpConf2Ack;
+
+ if (stateEngine != NULL) {
+ stateEngine->processEvent(&ev);
+ }
+}
+
+int32_t ZRtp::compareCommit(ZrtpPacketCommit *commit) {
+ // TODO: enhance to compare according to rules defined in chapter 4.2
+ int32_t len = 0;
+ len = !multiStream ? HVI_SIZE : (4 * ZRTP_WORD_SIZE);
+ return (memcmp(hvi, commit->getHvi(), len));
+}
+
+bool ZRtp::isEnrollmentMode() {
+ return enrollmentMode;
+}
+
+void ZRtp::setEnrollmentMode(bool enrollmentMode) {
+ this->enrollmentMode = enrollmentMode;
+}
+
+bool ZRtp::isPeerEnrolled() {
+ return peerIsEnrolled;
+}
+
+bool ZRtp::sendSASRelayPacket(uint8_t* sh, std::string render) {
+
+ uint8_t confMac[MAX_DIGEST_LENGTH];
+ uint32_t macLen;
+ uint8_t* hkey, *ekey;
+
+ // If we are responder then the PBX used it's Initiator keys
+ if (myRole == Responder) {
+ hkey = hmacKeyR;
+ ekey = zrtpKeyR;
+ // TODO: check signature length in zrtpConfirm1 and if not zero copy Signature data
+ }
+ else {
+ hkey = hmacKeyI;
+ ekey = zrtpKeyI;
+ // TODO: check signature length in zrtpConfirm2 and if not zero copy Signature data
+ }
+ // Prepare IV data that we will use during confirm packet encryption.
+ randomZRTP(randomIV, sizeof(randomIV));
+ zrtpSasRelay.setIv(randomIV);
+ zrtpSasRelay.setTrustedSas(sh);
+ zrtpSasRelay.setSas((uint8_t*)render.c_str());
+
+ // Encrypt and HMAC with Initiator's key - we are Initiator here
+ int16_t hmlen = (zrtpSasRelay.getLength() - 9) * ZRTP_WORD_SIZE;
+ cipher->getEncrypt()(ekey, cipher->getKeylen(), randomIV, (uint8_t*)zrtpSasRelay.getFiller(), hmlen);
+
+ // Use negotiated HMAC (hash)
+ hmacFunction(hkey, hashLength, (unsigned char*)zrtpSasRelay.getFiller(), hmlen, confMac, &macLen);
+
+ zrtpSasRelay.setHmac(confMac);
+
+ stateEngine->sendSASRelay(&zrtpSasRelay);
+ return true;
+}
+
+std::string ZRtp::getSasType() {
+ std::string sasT(sasType->getName());
+ return sasT;
+}
+
+uint8_t* ZRtp::getSasHash() {
+ return sasHash;
+}
+
+int32_t ZRtp::getPeerZid(uint8_t* data) {
+ memcpy(data, peerZid, IDENTIFIER_LEN);
+ return IDENTIFIER_LEN;
+}
+
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-default-style: ellemtel
+ * c-basic-offset: 4
+ * End:
+ */
+
diff --git a/src/ZrtpCWrapper.cpp b/src/ZrtpCWrapper.cpp
new file mode 100644
index 0000000..1e1d2c8
--- /dev/null
+++ b/src/ZrtpCWrapper.cpp
@@ -0,0 +1,470 @@
+/*
+ This class maps the ZRTP C calls to ZRTP C++ methods.
+ 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/>.
+
+*/
+
+#include <libzrtpcpp/ZrtpCallback.h>
+#include <libzrtpcpp/ZrtpConfigure.h>
+#include <libzrtpcpp/ZIDFile.h>
+#include <libzrtpcpp/ZRtp.h>
+#include <libzrtpcpp/ZrtpCallbackWrapper.h>
+#include <libzrtpcpp/ZrtpCWrapper.h>
+#include <libzrtpcpp/ZrtpCrc32.h>
+
+static int32_t zrtp_initZidFile(const char* zidFilename);
+
+ZrtpContext* zrtp_CreateWrapper()
+{
+ ZrtpContext* zc = new ZrtpContext;
+ zc->configure = 0;
+ zc->zrtpEngine = 0;
+ zc->zrtpCallback = 0;
+
+ return zc;
+}
+
+void zrtp_initializeZrtpEngine(ZrtpContext* zrtpContext,
+ zrtp_Callbacks *cb, const char* id,
+ const char* zidFilename,
+ void* userData,
+ int32_t mitmMode)
+{
+ std::string clientIdString(id);
+
+ zrtpContext->zrtpCallback = new ZrtpCallbackWrapper(cb, zrtpContext);
+ zrtpContext->userData = userData;
+
+ if (zrtpContext->configure == 0) {
+ zrtpContext->configure = new ZrtpConfigure();
+ zrtpContext->configure->setStandardConfig();
+ }
+
+ // Initialize ZID file (cache) and get my own ZID
+ zrtp_initZidFile(zidFilename);
+ ZIDFile* zf = ZIDFile::getInstance();
+ const unsigned char* myZid = zf->getZid();
+
+ zrtpContext->zrtpEngine = new ZRtp((uint8_t*)myZid, zrtpContext->zrtpCallback,
+ clientIdString, zrtpContext->configure, mitmMode == 0 ? false : true);
+}
+
+void zrtp_DestroyWrapper(ZrtpContext* zrtpContext) {
+
+ if (zrtpContext == NULL)
+ return;
+
+ delete zrtpContext->zrtpEngine;
+ zrtpContext->zrtpEngine = NULL;
+
+ delete zrtpContext->zrtpCallback;
+ zrtpContext->zrtpCallback = NULL;
+
+ delete zrtpContext->configure;
+ zrtpContext->configure = NULL;
+
+ delete zrtpContext;
+}
+
+static int32_t zrtp_initZidFile(const char* zidFilename) {
+ ZIDFile* zf = ZIDFile::getInstance();
+
+ if (!zf->isOpen()) {
+ std::string fname;
+ if (zidFilename == NULL) {
+ char *home = getenv("HOME");
+ std::string baseDir = (home != NULL) ? (std::string(home) + std::string("/."))
+ : std::string(".");
+ fname = baseDir + std::string("GNUccRTP.zid");
+ zidFilename = fname.c_str();
+ }
+ return zf->open((char *)zidFilename);
+ }
+ return 0;
+}
+
+int32_t zrtp_CheckCksum(uint8_t* buffer, uint16_t temp, uint32_t crc)
+{
+ return zrtpCheckCksum(buffer, temp, crc);
+}
+
+uint32_t zrtp_GenerateCksum(uint8_t* buffer, uint16_t temp)
+{
+ return zrtpGenerateCksum(buffer, temp);
+}
+
+uint32_t zrtp_EndCksum(uint32_t crc)
+{
+ return zrtpEndCksum(crc);
+}
+
+/*
+ * Applications use the following methods to control ZRTP, for example
+ * to enable ZRTP, set flags etc.
+ */
+void zrtp_startZrtpEngine(ZrtpContext* zrtpContext) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ zrtpContext->zrtpEngine->startZrtpEngine();
+}
+
+void zrtp_stopZrtpEngine(ZrtpContext* zrtpContext) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ zrtpContext->zrtpEngine->stopZrtp();
+}
+
+void zrtp_processZrtpMessage(ZrtpContext* zrtpContext, uint8_t *extHeader, uint32_t peerSSRC) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ zrtpContext->zrtpEngine->processZrtpMessage(extHeader, peerSSRC);
+}
+
+void zrtp_processTimeout(ZrtpContext* zrtpContext) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ zrtpContext->zrtpEngine->processTimeout();
+}
+
+//int32_t zrtp_handleGoClear(ZrtpContext* zrtpContext, uint8_t *extHeader)
+//{
+// if (zrtpContext && zrtpContext->zrtpEngine)
+// return zrtpContext->zrtpEngine->handleGoClear(extHeader) ? 1 : 0;
+//
+// return 0;
+//}
+
+void zrtp_setAuxSecret(ZrtpContext* zrtpContext, uint8_t* data, int32_t length) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ zrtpContext->zrtpEngine->setAuxSecret(data, length);
+}
+
+int32_t zrtp_inState(ZrtpContext* zrtpContext, int32_t state) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ return zrtpContext->zrtpEngine->inState(state) ? 1 : 0;
+
+ return 0;
+}
+
+void zrtp_SASVerified(ZrtpContext* zrtpContext) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ zrtpContext->zrtpEngine->SASVerified();
+}
+
+void zrtp_resetSASVerified(ZrtpContext* zrtpContext) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ zrtpContext->zrtpEngine->resetSASVerified();
+}
+
+char* zrtp_getHelloHash(ZrtpContext* zrtpContext) {
+ std::string ret;
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ ret = zrtpContext->zrtpEngine->getHelloHash();
+ else
+ return NULL;
+
+ if (ret.size() == 0)
+ return NULL;
+
+ char* retval = (char*)malloc(ret.size()+1);
+ strcpy(retval, ret.c_str());
+ return retval;
+}
+
+char* zrtp_getPeerHelloHash(ZrtpContext* zrtpContext) {
+ std::string ret;
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ ret = zrtpContext->zrtpEngine->getPeerHelloHash();
+ else
+ return NULL;
+
+ if (ret.size() == 0)
+ return NULL;
+
+ char* retval = (char*)malloc(ret.size()+1);
+ strcpy(retval, ret.c_str());
+ return retval;
+}
+
+char* zrtp_getMultiStrParams(ZrtpContext* zrtpContext, int32_t *length) {
+ std::string ret;
+
+ *length = 0;
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ ret = zrtpContext->zrtpEngine->getMultiStrParams();
+ else
+ return NULL;
+
+ if (ret.size() == 0)
+ return NULL;
+
+ *length = ret.size();
+ char* retval = (char*) malloc(ret.size());
+ ret.copy(retval, ret.size(), 0);
+ return retval;
+}
+
+void zrtp_setMultiStrParams(ZrtpContext* zrtpContext, char* parameters, int32_t length) {
+ if (!zrtpContext || !zrtpContext->zrtpEngine)
+ return;
+
+ if (parameters == NULL)
+ return;
+
+ std::string str("");
+ str.assign(parameters, length); // set chars (bytes) to the string
+
+ zrtpContext->zrtpEngine->setMultiStrParams(str);
+}
+
+int32_t zrtp_isMultiStream(ZrtpContext* zrtpContext) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ return zrtpContext->zrtpEngine->isMultiStream() ? 1 : 0;
+
+ return 0;
+}
+
+int32_t zrtp_isMultiStreamAvailable(ZrtpContext* zrtpContext) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ return zrtpContext->zrtpEngine->isMultiStreamAvailable() ? 1 : 0;
+
+ return 0;
+}
+
+void zrtp_acceptEnrollment(ZrtpContext* zrtpContext, int32_t accepted) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ return zrtpContext->zrtpEngine->acceptEnrollment(accepted == 0 ? false : true);
+}
+
+int32_t zrtp_isEnrollmentMode(ZrtpContext* zrtpContext) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ return zrtpContext->zrtpEngine->isEnrollmentMode() ? 1 : 0;
+
+ return 0;
+}
+
+void zrtp_setEnrollmentMode(ZrtpContext* zrtpContext, int32_t enrollmentMode) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ return zrtpContext->zrtpEngine->setEnrollmentMode(enrollmentMode == 0 ? false : true);
+}
+
+int32_t isPeerEnrolled(ZrtpContext* zrtpContext) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ return zrtpContext->zrtpEngine->isPeerEnrolled() ? 1 : 0;
+
+ return 0;
+}
+
+int32_t zrtp_sendSASRelayPacket(ZrtpContext* zrtpContext, uint8_t* sh, char* render) {
+ if (zrtpContext && zrtpContext->zrtpEngine) {
+ std::string rn(render);
+ return zrtpContext->zrtpEngine->sendSASRelayPacket(sh, rn) ? 1 : 0;
+ }
+ return 0;
+}
+
+
+const char* zrtp_getSasType(ZrtpContext* zrtpContext) {
+ if (zrtpContext && zrtpContext->zrtpEngine) {
+ std::string rn = zrtpContext->zrtpEngine->getSasType();
+ return rn.c_str();
+ }
+ return NULL;
+}
+
+
+uint8_t* zrtp_getSasHash(ZrtpContext* zrtpContext) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ return zrtpContext->zrtpEngine->getSasHash();
+
+ return NULL;
+}
+
+int32_t zrtp_setSignatureData(ZrtpContext* zrtpContext, uint8_t* data, int32_t length) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ return zrtpContext->zrtpEngine->setSignatureData(data, length) ? 1 : 0;
+
+ return 0;
+}
+
+const uint8_t* zrtp_getSignatureData(ZrtpContext* zrtpContext) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ return zrtpContext->zrtpEngine->getSignatureData();
+
+ return 0;
+}
+
+int32_t zrtp_getSignatureLength(ZrtpContext* zrtpContext) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ return zrtpContext->zrtpEngine->getSignatureLength();
+
+ return 0;
+}
+
+void zrtp_conf2AckSecure(ZrtpContext* zrtpContext) {
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ zrtpContext->zrtpEngine->conf2AckSecure();
+}
+
+int32_t zrtp_getPeerZid(ZrtpContext* zrtpContext, uint8_t* data) {
+ if (data == NULL)
+ return 0;
+
+ if (zrtpContext && zrtpContext->zrtpEngine)
+ return zrtpContext->zrtpEngine->getPeerZid(data);
+
+ return 0;
+}
+
+/*
+ * The following methods wrap the ZRTP Configure functions
+ */
+int32_t zrtp_InitializeConfig (ZrtpContext* zrtpContext)
+{
+ zrtpContext->configure = new ZrtpConfigure();
+ return 1;
+}
+
+static EnumBase* getEnumBase(zrtp_AlgoTypes type)
+{
+ switch(type) {
+ case zrtp_HashAlgorithm:
+ return &zrtpHashes;
+ break;
+
+ case zrtp_CipherAlgorithm:
+ return &zrtpSymCiphers;
+ break;
+
+ case zrtp_PubKeyAlgorithm:
+ return &zrtpPubKeys;
+ break;
+
+ case zrtp_SasType:
+ return &zrtpSasTypes;
+ break;
+
+ case zrtp_AuthLength:
+ return &zrtpAuthLengths;
+ break;
+
+ default:
+ return NULL;
+ }
+}
+
+char** zrtp_getAlgorithmNames(ZrtpContext* zrtpContext, Zrtp_AlgoTypes type)
+{
+ std::list<std::string>* names = NULL;
+ EnumBase* base = getEnumBase(type);
+
+ if (!base)
+ return NULL;
+
+ names = base->getAllNames();
+ int size = base->getSize();
+ char** cNames = new char* [size+1];
+ cNames[size] = NULL;
+
+ std::list<std::string >::iterator b = names->begin();
+ std::list<std::string >::iterator e = names->end();
+
+ for (int i = 0; b != e; b++, i++) {
+ cNames[i] = new char [(*b).size()+1];
+ strcpy(cNames[i], (*b).c_str());
+ }
+ return cNames;
+}
+
+void zrtp_freeAlgorithmNames(char** names)
+{
+ if (!names)
+ return;
+
+ for (char** cp = names; *cp; cp++)
+ delete *cp;
+
+ delete names;
+}
+
+void zrtp_setStandardConfig(ZrtpContext* zrtpContext)
+{
+ zrtpContext->configure->setStandardConfig();
+}
+
+void zrtp_setMandatoryOnly(ZrtpContext* zrtpContext)
+{
+ zrtpContext->configure->setMandatoryOnly();
+}
+
+int32_t zrtp_addAlgo(ZrtpContext* zrtpContext, zrtp_AlgoTypes algoType, const char* algo)
+{
+ EnumBase* base = getEnumBase(algoType);
+ AlgorithmEnum& a = base->getByName(algo);
+
+ return zrtpContext->configure->addAlgo((AlgoTypes)algoType, a);
+}
+
+int32_t zrtp_addAlgoAt(ZrtpContext* zrtpContext, zrtp_AlgoTypes algoType, const char* algo, int32_t index)
+{
+ EnumBase* base = getEnumBase(algoType);
+ AlgorithmEnum& a = base->getByName(algo);
+
+ return zrtpContext->configure->addAlgoAt((AlgoTypes)algoType, a, index);
+}
+
+int32_t zrtp_removeAlgo(ZrtpContext* zrtpContext, zrtp_AlgoTypes algoType, const char* algo)
+{
+ EnumBase* base = getEnumBase(algoType);
+ AlgorithmEnum& a = base->getByName(algo);
+
+ return zrtpContext->configure->removeAlgo((AlgoTypes)algoType, a);
+}
+
+int32_t zrtp_getNumConfiguredAlgos(ZrtpContext* zrtpContext, zrtp_AlgoTypes algoType)
+{
+ return zrtpContext->configure->getNumConfiguredAlgos((AlgoTypes)algoType);
+}
+
+const char* zrtp_getAlgoAt(ZrtpContext* zrtpContext, Zrtp_AlgoTypes algoType, int32_t index)
+{
+ AlgorithmEnum& a = zrtpContext->configure->getAlgoAt((AlgoTypes)algoType, index);
+ return a.getName();
+}
+
+int32_t zrtp_containsAlgo(ZrtpContext* zrtpContext, Zrtp_AlgoTypes algoType, const char* algo)
+{
+ EnumBase* base = getEnumBase(algoType);
+ AlgorithmEnum& a = base->getByName(algo);
+
+ return zrtpContext->configure->containsAlgo((AlgoTypes)algoType, a) ? 1 : 0;
+}
+
+void zrtp_setTrustedMitM(ZrtpContext* zrtpContext, int32_t yesNo)
+{
+ zrtpContext->configure->setTrustedMitM(yesNo ? true : false);
+}
+
+int32_t zrtp_isTrustedMitM(ZrtpContext* zrtpContext)
+{
+ return zrtpContext->configure->isTrustedMitM() ? 1 : 0;
+}
+
+void zrtp_setSasSignature(ZrtpContext* zrtpContext, int32_t yesNo)
+{
+ zrtpContext->configure->setSasSignature(yesNo ? true : false);
+}
+
+int32_t zrtp_isSasSignature(ZrtpContext* zrtpContext)
+{
+ return zrtpContext->configure->isSasSignature() ? 1 : 0;
+}
diff --git a/src/ZrtpCallbackWrapper.cpp b/src/ZrtpCallbackWrapper.cpp
new file mode 100644
index 0000000..ca2dce6
--- /dev/null
+++ b/src/ZrtpCallbackWrapper.cpp
@@ -0,0 +1,151 @@
+/*
+ This class maps the ZRTP C++ callback methods to C callback methods.
+ 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/>.
+
+*/
+
+#include <libzrtpcpp/ZrtpCallbackWrapper.h>
+
+ZrtpCallbackWrapper::ZrtpCallbackWrapper(zrtp_Callbacks* cb, ZrtpContext* ctx) :
+ c_callbacks(cb), zrtpCtx(ctx)
+{
+ init();
+}
+
+void ZrtpCallbackWrapper::init()
+{
+}
+/*
+* The following methods implement the GNU ZRTP callback interface.
+* For detailed documentation refer to file ZrtpCallback.h
+*/
+int32_t ZrtpCallbackWrapper::sendDataZRTP(const unsigned char* data, int32_t length)
+{
+ return c_callbacks->zrtp_sendDataZRTP(zrtpCtx, data, length);
+}
+
+int32_t ZrtpCallbackWrapper::activateTimer (int32_t time)
+{
+ c_callbacks->zrtp_activateTimer(zrtpCtx, time);
+ return 1;
+}
+
+int32_t ZrtpCallbackWrapper::cancelTimer()
+{
+ c_callbacks->zrtp_cancelTimer(zrtpCtx);
+ return 0;
+}
+
+void ZrtpCallbackWrapper::sendInfo (GnuZrtpCodes::MessageSeverity severity, int32_t subCode)
+{
+ c_callbacks->zrtp_sendInfo(zrtpCtx, (int32_t)severity, subCode);
+}
+
+bool ZrtpCallbackWrapper::srtpSecretsReady(SrtpSecret_t* secrets, EnableSecurity part)
+{
+ C_SrtpSecret_t* cs = new C_SrtpSecret_t;
+ cs->symEncAlgorithm = (zrtp_SrtpAlgorithms)secrets->symEncAlgorithm;
+ cs->initKeyLen = secrets->initKeyLen;
+ cs->initSaltLen = secrets->initSaltLen;
+ cs->keyInitiator = secrets->keyInitiator;
+ cs->keyResponder = secrets->keyResponder;
+ cs->respKeyLen = secrets->respKeyLen;
+ cs->respSaltLen = secrets->respSaltLen;
+ cs->role = (int32_t)secrets->role;
+ cs->saltInitiator = secrets->saltInitiator;
+ cs->saltResponder = secrets->saltResponder;
+ cs->sas = new char [secrets->sas.size()+1];
+ strcpy(cs->sas, secrets->sas.c_str());
+ cs->authAlgorithm = (zrtp_SrtpAlgorithms)secrets->authAlgorithm;
+ cs->srtpAuthTagLen = secrets->srtpAuthTagLen;
+
+ bool retval = (c_callbacks->zrtp_srtpSecretsReady(zrtpCtx, cs, (int32_t)part) == 0) ? false : true ;
+
+ delete[] cs->sas;
+ delete cs;
+
+ return retval;
+}
+
+void ZrtpCallbackWrapper::srtpSecretsOff (EnableSecurity part )
+{
+ c_callbacks->zrtp_srtpSecretsOff(zrtpCtx, (int32_t)part);
+}
+
+void ZrtpCallbackWrapper::srtpSecretsOn ( std::string c, std::string s, bool verified )
+{
+ char* cc = new char [c.size()+1];
+ char* cs = new char [s.size()+1];
+
+ strcpy(cc, c.c_str());
+ if(!s.empty())
+ strcpy(cs, s.c_str());
+ else
+ *cs = '\0';
+
+ c_callbacks->zrtp_rtpSecretsOn(zrtpCtx, cc, cs, verified?1:0);
+
+ delete[] cc;
+ delete[] cs;
+}
+
+void ZrtpCallbackWrapper::handleGoClear()
+{
+}
+
+void ZrtpCallbackWrapper::zrtpNegotiationFailed(GnuZrtpCodes::MessageSeverity severity, int32_t subCode)
+{
+ c_callbacks->zrtp_zrtpNegotiationFailed(zrtpCtx, (int32_t)severity, subCode);
+}
+
+void ZrtpCallbackWrapper::zrtpNotSuppOther()
+{
+ c_callbacks->zrtp_zrtpNotSuppOther(zrtpCtx);
+}
+
+void ZrtpCallbackWrapper::synchEnter()
+{
+ c_callbacks->zrtp_synchEnter(zrtpCtx);
+}
+
+
+void ZrtpCallbackWrapper::synchLeave()
+{
+ c_callbacks->zrtp_synchLeave(zrtpCtx);
+}
+
+void ZrtpCallbackWrapper::zrtpAskEnrollment(GnuZrtpCodes::InfoEnrollment info)
+{
+ c_callbacks->zrtp_zrtpAskEnrollment(zrtpCtx, (zrtp_InfoEnrollment)info);
+}
+
+void ZrtpCallbackWrapper::zrtpInformEnrollment(GnuZrtpCodes::InfoEnrollment info)
+{
+ c_callbacks->zrtp_zrtpInformEnrollment(zrtpCtx, (zrtp_InfoEnrollment)info);
+
+}
+
+void ZrtpCallbackWrapper::signSAS(uint8_t* sasHash)
+{
+ c_callbacks->zrtp_signSAS(zrtpCtx, sasHash);
+}
+
+bool ZrtpCallbackWrapper::checkSASSignature(uint8_t* sasHash)
+{
+ bool retval = (c_callbacks->zrtp_checkSASSignature(zrtpCtx, sasHash) == 0) ? false : true;
+
+ return retval;
+}
diff --git a/src/ZrtpConfigure.cpp b/src/ZrtpConfigure.cpp
new file mode 100644
index 0000000..560466f
--- /dev/null
+++ b/src/ZrtpConfigure.cpp
@@ -0,0 +1,496 @@
+#include <libzrtpcpp/crypto/aesCFB.h>
+#include <libzrtpcpp/crypto/twoCFB.h>
+#include <libzrtpcpp/ZrtpConfigure.h>
+#include <libzrtpcpp/ZrtpTextData.h>
+
+AlgorithmEnum::AlgorithmEnum(const AlgoTypes type, const char* name,
+ int32_t klen, const char* ra, encrypt_t en,
+ decrypt_t de, SrtpAlgorithms alId):
+ algoType(type) , algoName(name), keyLen(klen), readable(ra), encrypt(en),
+ decrypt(de), algoId(alId) {
+}
+
+AlgorithmEnum::~AlgorithmEnum()
+{
+}
+
+const char* AlgorithmEnum::getName() {
+ return algoName.c_str();
+}
+
+const char* AlgorithmEnum::getReadable() {
+ return readable.c_str();
+}
+
+int AlgorithmEnum::getKeylen() {
+ return keyLen;
+}
+
+SrtpAlgorithms AlgorithmEnum::getAlgoId() {
+ return algoId;
+}
+
+encrypt_t AlgorithmEnum::getEncrypt() {
+ return encrypt;
+}
+
+decrypt_t AlgorithmEnum::getDecrypt() {
+ return decrypt;
+}
+
+AlgoTypes AlgorithmEnum::getAlgoType() {
+ return algoType;
+}
+
+bool AlgorithmEnum::isValid() {
+ return (algoType != Invalid);
+}
+
+static AlgorithmEnum invalidAlgo(Invalid, "", 0, "", NULL, NULL, None);
+
+
+EnumBase::EnumBase(AlgoTypes a) : algoType(a) {
+}
+
+EnumBase::~EnumBase() {}
+
+void EnumBase::insert(const char* name) {
+ if (!name)
+ return;
+ AlgorithmEnum* e = new AlgorithmEnum(algoType, name, 0, "", NULL, NULL, None);
+ algos.push_back(e);
+}
+
+void EnumBase::insert(const char* name, int32_t klen, const char* ra,
+ encrypt_t enc, decrypt_t dec, SrtpAlgorithms alId) {
+ if (!name)
+ return;
+ AlgorithmEnum* e = new AlgorithmEnum(algoType, name, klen, ra, enc, dec, alId);
+ algos.push_back(e);
+}
+
+int EnumBase::getSize() {
+ return algos.size();
+}
+
+AlgoTypes EnumBase::getAlgoType() {
+ return algoType;
+}
+
+AlgorithmEnum& EnumBase::getByName(const char* name) {
+ std::vector<AlgorithmEnum* >::iterator b = algos.begin();
+ std::vector<AlgorithmEnum* >::iterator e = algos.end();
+
+ for (; b != e; b++) {
+ if (strncmp((*b)->getName(), name, 4) == 0) {
+ return *(*b);
+ }
+ }
+ return invalidAlgo;
+}
+
+AlgorithmEnum& EnumBase::getByOrdinal(int ord) {
+ std::vector<AlgorithmEnum* >::iterator b = algos.begin();
+ std::vector<AlgorithmEnum* >::iterator e = algos.end();
+
+ for (int i = 0; b != e; ++b) {
+ if (i == ord) {
+ return *(*b);
+ }
+ i++;
+ }
+ return invalidAlgo;
+}
+
+int EnumBase::getOrdinal(AlgorithmEnum& algo) {
+ std::vector<AlgorithmEnum* >::iterator b = algos.begin();
+ std::vector<AlgorithmEnum* >::iterator e = algos.end();
+
+ for (int i = 0; b != e; ++b) {
+ if (strncmp((*b)->getName(), algo.getName(), 4) == 0) {
+ return i;
+ }
+ i++;
+ }
+ return -1;
+}
+
+std::list<std::string>* EnumBase::getAllNames() {
+ std::vector<AlgorithmEnum* >::iterator b = algos.begin();
+ std::vector<AlgorithmEnum* >::iterator e = algos.end();
+
+ std::list<std::string>* strg = new std::list<std::string>();
+
+ for (; b != e; b++) {
+ std::string s((*b)->getName());
+ strg->push_back(s);
+ }
+ return strg;
+}
+
+
+/**
+ * Set up the enumeration list for available hash algorithms
+ */
+HashEnum::HashEnum() : EnumBase(HashAlgorithm) {
+ insert(s256);
+ insert(s384);
+}
+
+HashEnum::~HashEnum() {}
+
+/**
+ * Set up the enumeration list for available symmetric cipher algorithms
+ */
+SymCipherEnum::SymCipherEnum() : EnumBase(CipherAlgorithm) {
+ insert(aes3, 32, "AES-CM-256", aesCfbEncrypt, aesCfbDecrypt, Aes);
+ insert(aes1, 16, "AES-CM-128", aesCfbEncrypt, aesCfbDecrypt, Aes);
+ insert(two3, 32, "TWO-CM-256", twoCfbEncrypt, twoCfbDecrypt, TwoFish);
+ insert(two1, 16, "TWO-CM-128", twoCfbEncrypt, twoCfbDecrypt, TwoFish);
+}
+
+SymCipherEnum::~SymCipherEnum() {}
+
+/**
+ * Set up the enumeration list for available public key algorithms
+ */
+PubKeyEnum::PubKeyEnum() : EnumBase(PubKeyAlgorithm) {
+ insert(dh2k);
+ insert(dh3k);
+ insert(mult);
+ insert(ec25);
+ insert(ec38);
+}
+
+PubKeyEnum::~PubKeyEnum() {}
+
+/**
+ * Set up the enumeration list for available SAS algorithms
+ */
+SasTypeEnum::SasTypeEnum() : EnumBase(SasType) {
+ insert(b32);
+}
+
+SasTypeEnum::~SasTypeEnum() {}
+
+/**
+ * Set up the enumeration list for available SRTP authentications
+ */
+AuthLengthEnum::AuthLengthEnum() : EnumBase(AuthLength) {
+ insert(hs32, 32, "", NULL, NULL, Sha1);
+ insert(hs80, 80, "", NULL, NULL, Sha1);
+ insert(sk32, 32, "", NULL, NULL, Skein);
+ insert(sk64, 64, "", NULL, NULL, Skein);
+}
+
+AuthLengthEnum::~AuthLengthEnum() {}
+
+/*
+ * Here the global accessible enumerations for all implemented algorithms.
+ */
+HashEnum zrtpHashes;
+SymCipherEnum zrtpSymCiphers;
+PubKeyEnum zrtpPubKeys;
+SasTypeEnum zrtpSasTypes;
+AuthLengthEnum zrtpAuthLengths;
+
+/*
+ * The public methods are mainly a facade to the private methods.
+ */
+ZrtpConfigure::ZrtpConfigure() : enableTrustedMitM(false), enableSasSignature(false), enableParanoidMode(false) {}
+
+ZrtpConfigure::~ZrtpConfigure() {}
+
+void ZrtpConfigure::setStandardConfig() {
+ clear();
+
+ addAlgo(HashAlgorithm, zrtpHashes.getByName(s384));
+ addAlgo(HashAlgorithm, zrtpHashes.getByName(s256));
+
+ addAlgo(CipherAlgorithm, zrtpSymCiphers.getByName(two3));
+ addAlgo(CipherAlgorithm, zrtpSymCiphers.getByName(aes3));
+ addAlgo(CipherAlgorithm, zrtpSymCiphers.getByName(two1));
+ addAlgo(CipherAlgorithm, zrtpSymCiphers.getByName(aes1));
+
+ addAlgo(PubKeyAlgorithm, zrtpPubKeys.getByName(ec25));
+ addAlgo(PubKeyAlgorithm, zrtpPubKeys.getByName(dh3k));
+ addAlgo(PubKeyAlgorithm, zrtpPubKeys.getByName(ec38));
+ addAlgo(PubKeyAlgorithm, zrtpPubKeys.getByName(dh2k));
+ addAlgo(PubKeyAlgorithm, zrtpPubKeys.getByName(mult));
+
+ addAlgo(SasType, zrtpSasTypes.getByName(b32));
+
+ addAlgo(AuthLength, zrtpAuthLengths.getByName(sk32));
+ addAlgo(AuthLength, zrtpAuthLengths.getByName(sk64));
+ addAlgo(AuthLength, zrtpAuthLengths.getByName(hs32));
+ addAlgo(AuthLength, zrtpAuthLengths.getByName(hs80));
+}
+
+void ZrtpConfigure::setMandatoryOnly() {
+ clear();
+
+ addAlgo(HashAlgorithm, zrtpHashes.getByName(s256));
+
+ addAlgo(CipherAlgorithm, zrtpSymCiphers.getByName(aes1));
+
+ addAlgo(PubKeyAlgorithm, zrtpPubKeys.getByName(dh3k));
+ addAlgo(PubKeyAlgorithm, zrtpPubKeys.getByName(mult));
+
+ addAlgo(SasType, zrtpSasTypes.getByName(b32));
+
+ addAlgo(AuthLength, zrtpAuthLengths.getByName(hs32));
+ addAlgo(AuthLength, zrtpAuthLengths.getByName(hs80));
+
+}
+
+void ZrtpConfigure::clear() {
+ hashes.clear();
+ symCiphers.clear();
+ publicKeyAlgos.clear();
+ sasTypes.clear();
+ authLengths.clear();
+}
+
+int32_t ZrtpConfigure::addAlgo(AlgoTypes algoType, AlgorithmEnum& algo) {
+
+ return addAlgo(getEnum(algoType), algo);
+}
+
+int32_t ZrtpConfigure::addAlgoAt(AlgoTypes algoType, AlgorithmEnum& algo, int32_t index) {
+
+ return addAlgoAt(getEnum(algoType), algo, index);
+}
+
+AlgorithmEnum& ZrtpConfigure::getAlgoAt(AlgoTypes algoType, int32_t index) {
+
+ return getAlgoAt(getEnum(algoType), index);
+}
+
+int32_t ZrtpConfigure::removeAlgo(AlgoTypes algoType, AlgorithmEnum& algo) {
+
+ return removeAlgo(getEnum(algoType), algo);
+}
+
+int32_t ZrtpConfigure::getNumConfiguredAlgos(AlgoTypes algoType) {
+
+ return getNumConfiguredAlgos(getEnum(algoType));
+}
+
+bool ZrtpConfigure::containsAlgo(AlgoTypes algoType, AlgorithmEnum& algo) {
+
+ return containsAlgo(getEnum(algoType), algo);
+}
+
+void ZrtpConfigure::printConfiguredAlgos(AlgoTypes algoType) {
+
+ printConfiguredAlgos(getEnum(algoType));
+}
+
+/*
+ * The next methods are the private methods that implement the real
+ * details.
+ */
+AlgorithmEnum& ZrtpConfigure::getAlgoAt(std::vector<AlgorithmEnum* >& a, int32_t index) {
+
+ if (index >= (int)a.size())
+ return invalidAlgo;
+
+ std::vector<AlgorithmEnum* >::iterator b = a.begin();
+ std::vector<AlgorithmEnum* >::iterator e = a.end();
+
+ for (int i = 0; b != e; ++b) {
+ if (i == index) {
+ return *(*b);
+ }
+ i++;
+ }
+ return invalidAlgo;
+}
+
+int32_t ZrtpConfigure::addAlgo(std::vector<AlgorithmEnum* >& a, AlgorithmEnum& algo) {
+ int size = (int)a.size();
+ if (size >= maxNoOfAlgos)
+ return -1;
+
+ if (!algo.isValid())
+ return -1;
+
+ if (containsAlgo(a, algo))
+ return (maxNoOfAlgos - size);
+
+ a.push_back(&algo);
+ return (maxNoOfAlgos - (int)a.size());
+}
+
+int32_t ZrtpConfigure::addAlgoAt(std::vector<AlgorithmEnum* >& a, AlgorithmEnum& algo, int32_t index) {
+ if (index >= maxNoOfAlgos)
+ return -1;
+
+ int size = (int)a.size();
+
+ if (!algo.isValid())
+ return -1;
+
+// a[index] = &algo;
+
+ if (index >= size) {
+ a.push_back(&algo);
+ return maxNoOfAlgos - (int)a.size();
+ }
+ std::vector<AlgorithmEnum* >::iterator b = a.begin();
+ std::vector<AlgorithmEnum* >::iterator e = a.end();
+
+ for (int i = 0; b != e; ++b) {
+ if (i == index) {
+ a.insert(b, &algo);
+ break;
+ }
+ i++;
+ }
+ return (maxNoOfAlgos - (int)a.size());
+}
+
+int32_t ZrtpConfigure::removeAlgo(std::vector<AlgorithmEnum* >& a, AlgorithmEnum& algo) {
+
+ if ((int)a.size() == 0 || !algo.isValid())
+ return maxNoOfAlgos;
+
+ std::vector<AlgorithmEnum* >::iterator b = a.begin();
+ std::vector<AlgorithmEnum* >::iterator e = a.end();
+
+ for (; b != e; ++b) {
+ if (strcmp((*b)->getName(), algo.getName()) == 0) {
+ a.erase(b);
+ break;
+ }
+ }
+ return (maxNoOfAlgos - (int)a.size());
+}
+
+int32_t ZrtpConfigure::getNumConfiguredAlgos(std::vector<AlgorithmEnum* >& a) {
+ return (int32_t)a.size();
+}
+
+bool ZrtpConfigure::containsAlgo(std::vector<AlgorithmEnum* >& a, AlgorithmEnum& algo) {
+
+ if ((int)a.size() == 0 || !algo.isValid())
+ return false;
+
+ std::vector<AlgorithmEnum* >::iterator b = a.begin();
+ std::vector<AlgorithmEnum* >::iterator e = a.end();
+
+ for (; b != e; ++b) {
+ if (strcmp((*b)->getName(), algo.getName()) == 0) {
+ return true;
+ }
+ }
+ return false;
+}
+
+void ZrtpConfigure::printConfiguredAlgos(std::vector<AlgorithmEnum* >& a) {
+
+ std::vector<AlgorithmEnum* >::iterator b = a.begin();
+ std::vector<AlgorithmEnum* >::iterator e = a.end();
+
+ for (; b != e; ++b) {
+ printf("print configured: name: %s\n", (*b)->getName());
+ }
+}
+
+std::vector<AlgorithmEnum* >& ZrtpConfigure::getEnum(AlgoTypes algoType) {
+
+ switch(algoType) {
+ case HashAlgorithm:
+ return hashes;
+ break;
+
+ case CipherAlgorithm:
+ return symCiphers;
+ break;
+
+ case PubKeyAlgorithm:
+ return publicKeyAlgos;
+ break;
+
+ case SasType:
+ return sasTypes;
+ break;
+
+ case AuthLength:
+ return authLengths;
+ break;
+
+ default:
+ break;
+ }
+ return hashes;
+}
+
+void ZrtpConfigure::setTrustedMitM(bool yesNo) {
+ enableTrustedMitM = yesNo;
+}
+
+bool ZrtpConfigure::isTrustedMitM() {
+ return enableTrustedMitM;
+}
+
+void ZrtpConfigure::setSasSignature(bool yesNo) {
+ enableSasSignature = yesNo;
+}
+
+bool ZrtpConfigure::isSasSignature() {
+ return enableSasSignature;
+}
+
+void ZrtpConfigure::setParanoidMode(bool yesNo) {
+ enableParanoidMode = yesNo;
+}
+
+bool ZrtpConfigure::isParanoidMode() {
+ return enableParanoidMode;
+}
+
+#if 0
+ZrtpConfigure config;
+
+main() {
+ printf("Start\n");
+ printf("size: %d\n", zrtpHashes.getSize());
+ AlgorithmEnum e = zrtpHashes.getByName("S256");
+ printf("algo name: %s\n", e.getName());
+ printf("algo type: %d\n", e.getAlgoType());
+
+ std::list<std::string>* names = zrtpHashes.getAllNames();
+ printf("size of name list: %d\n", names->size());
+ printf("first name: %s\n", names->front().c_str());
+ printf("last name: %s\n", names->back().c_str());
+
+ printf("free slots: %d (expected 6)\n", config.addAlgo(HashAlgorithm, e));
+
+ AlgorithmEnum e1(HashAlgorithm, "SHA384");
+ printf("free slots: %d (expected 5)\n", config.addAlgoAt(HashAlgorithm, e1, 0));
+ AlgorithmEnum e2 = config.getAlgoAt(HashAlgorithm, 0);
+ printf("algo name: %s (expected SHA384)\n", e2.getName());
+ printf("Num of configured algos: %d (expected 2)\n", config.getNumConfiguredAlgos(HashAlgorithm));
+ config.printConfiguredAlgos(HashAlgorithm);
+ printf("free slots: %d (expected 6)\n", config.removeAlgo(HashAlgorithm, e2));
+ e2 = config.getAlgoAt(HashAlgorithm, 0);
+ printf("algo name: %s (expected SHA256)\n", e2.getName());
+
+ printf("clearing config\n");
+ config.clear();
+ printf("size: %d\n", zrtpHashes.getSize());
+ e = zrtpHashes.getByName("S256");
+ printf("algo name: %s\n", e.getName());
+ printf("algo type: %d\n", e.getAlgoType());
+
+}
+
+#endif
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-default-style: ellemtel
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/src/ZrtpCrc32.cpp b/src/ZrtpCrc32.cpp
new file mode 100644
index 0000000..c65b19a
--- /dev/null
+++ b/src/ZrtpCrc32.cpp
@@ -0,0 +1,223 @@
+/* SCTP kernel reference Implementation
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001-2003 International Business Machines, Corp.
+ *
+ * SCTP Checksum functions
+ *
+ * The SCTP reference implementation 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 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation 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 GNU CC; see the file COPYING. If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ * lksctp developers <lksctp-developers@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ * http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ * Dinakaran Joseph
+ * Jon Grimm <jgrimm@us.ibm.com>
+ * Sridhar Samudrala <sri@us.ibm.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+/* The following code has been taken directly from
+ * draft-ietf-tsvwg-sctpcsum-03.txt
+ *
+ * The code has now been modified by Werner.Dittmann@t-online.de for use
+ * inside the ZRTP implementation.
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <libzrtpcpp/ZrtpCrc32.h>
+
+#define CRC32C_POLY 0x1EDC6F41
+#define CRC32C(c,d) (c=(c>>8)^crc_c[(c^(d))&0xFF])
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/* Copyright 2001, D. Otis. Use this program, code or tables */
+/* extracted from it, as desired without restriction. */
+/* */
+/* 32 Bit Reflected CRC table generation for SCTP. */
+/* To accommodate serial byte data being shifted out least */
+/* significant bit first, the table's 32 bit words are reflected */
+/* which flips both byte and bit MS and LS positions. The CRC */
+/* is calculated MS bits first from the perspective of the serial*/
+/* stream. The x^32 term is implied and the x^0 term may also */
+/* be shown as +1. The polynomial code used is 0x1EDC6F41. */
+/* Castagnoli93 */
+/* x^32+x^28+x^27+x^26+x^25+x^23+x^22+x^20+x^19+x^18+x^14+x^13+ */
+/* x^11+x^10+x^9+x^8+x^6+x^0 */
+/* Guy Castagnoli Stefan Braeuer and Martin Herrman */
+/* "Optimization of Cyclic Redundancy-Check Codes */
+/* with 24 and 32 Parity Bits", */
+/* IEEE Transactions on Communications, Vol.41, No.6, June 1993 */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+static const uint32_t crc_c[256] = {
+ 0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4,
+ 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
+ 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B,
+ 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
+ 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B,
+ 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
+ 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54,
+ 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
+ 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A,
+ 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
+ 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5,
+ 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
+ 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45,
+ 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
+ 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A,
+ 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
+ 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48,
+ 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
+ 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687,
+ 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
+ 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927,
+ 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
+ 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8,
+ 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
+ 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096,
+ 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
+ 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859,
+ 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
+ 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9,
+ 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
+ 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36,
+ 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
+ 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C,
+ 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
+ 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043,
+ 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
+ 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3,
+ 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
+ 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C,
+ 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
+ 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652,
+ 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
+ 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D,
+ 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
+ 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D,
+ 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
+ 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2,
+ 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
+ 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530,
+ 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
+ 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF,
+ 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
+ 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F,
+ 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
+ 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90,
+ 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
+ 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE,
+ 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
+ 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321,
+ 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
+ 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81,
+ 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
+ 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E,
+ 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351,
+};
+
+
+bool zrtpCheckCksum(uint8_t *buffer, uint16_t length, uint32_t crc32)
+{
+ uint32_t chksum = zrtpGenerateCksum(buffer, length);
+ chksum = zrtpEndCksum(chksum);
+ // fprintf(stderr, "Received crc %x, computed crc: %x\n", crc32, chksum);
+ return (crc32 == chksum);
+}
+
+uint32_t zrtpGenerateCksum(uint8_t *buffer, uint16_t length)
+{
+ uint32_t crc32 = ~(uint32_t) 0;
+ uint32_t i;
+
+ // fprintf(stderr, "Buffer %xl, length: %d\n", buffer, length);
+ /* Calculate the CRC. */
+ for (i = 0; i < length ; i++)
+ CRC32C(crc32, buffer[i]);
+
+ return crc32;
+}
+
+uint32_t zrtpEndCksum(uint32_t crc32)
+{
+ uint32_t result;
+ uint8_t byte0, byte1, byte2, byte3;
+
+ result = ~crc32;
+
+ /* result now holds the negated polynomial remainder;
+ * since the table and algorithm is "reflected" [williams95].
+ * That is, result has the same value as if we mapped the message
+ * to a polyomial, computed the host-bit-order polynomial
+ * remainder, performed final negation, then did an end-for-end
+ * bit-reversal.
+ * Note that a 32-bit bit-reversal is identical to four inplace
+ * 8-bit reversals followed by an end-for-end byteswap.
+ * In other words, the bytes of each bit are in the right order,
+ * but the bytes have been byteswapped. So we now do an explicit
+ * byteswap. On a little-endian machine, this byteswap and
+ * the final ntohl cancel out and could be elided.
+ */
+ byte0 = result & 0xff;
+ byte1 = (result>>8) & 0xff;
+ byte2 = (result>>16) & 0xff;
+ byte3 = (result>>24) & 0xff;
+
+ crc32 = ((byte0 << 24) |
+ (byte1 << 16) |
+ (byte2 << 8) |
+ byte3);
+ // fprintf(stderr, "Computed crc32: %x\n", crc32);
+ return crc32;
+}
+
+#ifdef UNIT_TEST
+uint8_t test_data[48] = {
+ 0x01, 0xC0, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x01, 0xFE, 0x60, 0xAC,
+ 0x00, 0x00, 0x00, 0x08,
+ 0x00, 0x00, 0x00, 0x04,
+ 0x00, 0x00, 0x00, 0x09,
+ 0x25, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+};
+
+int main( int argc, char * argv[] )
+{
+ crc32c = sctp_update_cksum(test_data, 48);
+ printf("Hello World, expected result: 0x664f75eb\n");
+ printf("Result is: 0x%x\n", crc32c);
+}
+#endif
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-default-style: ellemtel
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/src/ZrtpPacketClearAck.cpp b/src/ZrtpPacketClearAck.cpp
new file mode 100644
index 0000000..85f1484
--- /dev/null
+++ b/src/ZrtpPacketClearAck.cpp
@@ -0,0 +1,42 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/*
+ * @author: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <libzrtpcpp/ZrtpPacketClearAck.h>
+
+ZrtpPacketClearAck::ZrtpPacketClearAck() {
+ DEBUGOUT((fprintf(stdout, "Creating ClearAck packet without data\n")));
+
+ zrtpHeader = &data.hdr; // the standard header
+
+ setZrtpId();
+ setLength((sizeof(ClearAckPacket_t) / ZRTP_WORD_SIZE) - 1);
+ setMessageType((uint8_t*)ClearAckMsg);
+}
+
+ZrtpPacketClearAck::ZrtpPacketClearAck(uint8_t *data) {
+ DEBUGOUT((fprintf(stdout, "Creating Conf2Ack packet from data\n")));
+
+ zrtpHeader = (zrtpPacketHeader_t *)&((ClearAckPacket_t*)data)->hdr; // the standard header
+}
+
+ZrtpPacketClearAck::~ZrtpPacketClearAck() {
+ DEBUGOUT((fprintf(stdout, "Deleting ClearAck packet: alloc: %x\n", allocated)));
+}
diff --git a/src/ZrtpPacketCommit.cpp b/src/ZrtpPacketCommit.cpp
new file mode 100644
index 0000000..97a162a
--- /dev/null
+++ b/src/ZrtpPacketCommit.cpp
@@ -0,0 +1,50 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/*
+ * @author: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <libzrtpcpp/ZrtpPacketCommit.h>
+
+ZrtpPacketCommit::ZrtpPacketCommit() {
+ DEBUGOUT((fprintf(stdout, "Creating commit packet without data\n")));
+
+ zrtpHeader = &data.hdr; // the standard header
+ commitHeader = &data.commit;
+
+ setZrtpId();
+ setLength((sizeof (CommitPacket_t) / ZRTP_WORD_SIZE) - 1);
+ setMessageType((uint8_t*)CommitMsg);
+}
+
+void ZrtpPacketCommit::setNonce(uint8_t* text) {
+ memcpy(commitHeader->hvi, text, sizeof(commitHeader->hvi) - 4 * ZRTP_WORD_SIZE);
+ uint16_t len = getLength();
+ len -= 4;
+ setLength(len);
+}
+
+ZrtpPacketCommit::ZrtpPacketCommit(uint8_t *data) {
+ DEBUGOUT((fprintf(stdout, "Creating commit packet from data\n")));
+ zrtpHeader = (zrtpPacketHeader_t *)&((CommitPacket_t *)data)->hdr; // the standard header
+ commitHeader = (Commit_t *)&((CommitPacket_t *)data)->commit;
+}
+
+ZrtpPacketCommit::~ZrtpPacketCommit() {
+ DEBUGOUT((fprintf(stdout, "Deleting commit packet: alloc: %x\n", allocated)));
+}
diff --git a/src/ZrtpPacketConf2Ack.cpp b/src/ZrtpPacketConf2Ack.cpp
new file mode 100644
index 0000000..f35dc82
--- /dev/null
+++ b/src/ZrtpPacketConf2Ack.cpp
@@ -0,0 +1,42 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <libzrtpcpp/ZrtpPacketConf2Ack.h>
+
+ZrtpPacketConf2Ack::ZrtpPacketConf2Ack() {
+ DEBUGOUT((fprintf(stdout, "Creating Conf2Ack packet without data\n")));
+
+ zrtpHeader = &data.hdr; // the standard header
+
+ setZrtpId();
+ setLength((sizeof (Conf2AckPacket_t) / ZRTP_WORD_SIZE) - 1);
+ setMessageType((uint8_t*)Conf2AckMsg);
+}
+
+ZrtpPacketConf2Ack::ZrtpPacketConf2Ack(char *data) {
+ DEBUGOUT((fprintf(stdout, "Creating Conf2Ack packet from data\n")));
+
+ zrtpHeader = (zrtpPacketHeader_t *)&((Conf2AckPacket_t*)data)->hdr; // the standard header
+}
+
+ZrtpPacketConf2Ack::~ZrtpPacketConf2Ack() {
+ DEBUGOUT((fprintf(stdout, "Deleting Conf2Ack packet: alloc: %x\n", allocated)));
+}
diff --git a/src/ZrtpPacketConfirm.cpp b/src/ZrtpPacketConfirm.cpp
new file mode 100644
index 0000000..f558759
--- /dev/null
+++ b/src/ZrtpPacketConfirm.cpp
@@ -0,0 +1,87 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <libzrtpcpp/ZrtpPacketConfirm.h>
+
+ZrtpPacketConfirm::ZrtpPacketConfirm() {
+ DEBUGOUT((fprintf(stdout, "Creating Confirm packet without data, no sl data\n")));
+ initialize();
+ setSignatureLength(0);
+}
+
+ZrtpPacketConfirm::ZrtpPacketConfirm(uint32_t sl) {
+ DEBUGOUT((fprintf(stdout, "Creating Confirm packet without data\n")));
+ initialize();
+ setSignatureLength(sl);
+}
+
+void ZrtpPacketConfirm::initialize() {
+ void* allocated = &data;
+ memset(allocated, 0, sizeof(data));
+
+ zrtpHeader = (zrtpPacketHeader_t *)&((ConfirmPacket_t *)allocated)->hdr; // the standard header
+ confirmHeader = (Confirm_t *)&((ConfirmPacket_t *)allocated)->confirm;
+
+ setZrtpId();
+}
+
+bool ZrtpPacketConfirm::setSignatureLength(uint32_t sl) {
+ if (sl > 512)
+ return false;
+
+ int32_t length = sizeof(ConfirmPacket_t) + (sl * ZRTP_WORD_SIZE);
+ confirmHeader->sigLength = sl; // sigLength is a uint byte
+ if (sl & 0x100) { // check the 9th bit
+ confirmHeader->filler[1] = 1; // and set it if necessary
+ }
+ setLength(length / 4);
+ return true;
+}
+
+bool ZrtpPacketConfirm::setSignatureData(uint8_t* data, int32_t length) {
+ int32_t l = getSignatureLength() * 4;
+ if (length > l || (length % 4) != 0)
+ return false;
+
+ uint8_t* p = ((uint8_t*)&confirmHeader->expTime) + 4; // point to signature block
+ memcpy(p, data, length);
+ return true;
+}
+
+int32_t ZrtpPacketConfirm::getSignatureLength() {
+ int32_t sl = confirmHeader->sigLength & 0xff;
+ if (confirmHeader->filler[1] == 1) { // do we have a 9th bit
+ sl |= 0x100;
+ }
+ return sl;
+}
+
+ZrtpPacketConfirm::ZrtpPacketConfirm(uint8_t* data) {
+ DEBUGOUT((fprintf(stdout, "Creating Confirm packet from data\n")));
+
+ allocated = NULL;
+ zrtpHeader = (zrtpPacketHeader_t *)&((ConfirmPacket_t *)data)->hdr; // the standard header
+ confirmHeader = (Confirm_t *)&((ConfirmPacket_t *)data)->confirm;
+}
+
+ZrtpPacketConfirm::~ZrtpPacketConfirm() {
+ DEBUGOUT((fprintf(stdout, "Deleting Confirm packet: alloc: %x\n", allocated)));
+}
diff --git a/src/ZrtpPacketDHPart.cpp b/src/ZrtpPacketDHPart.cpp
new file mode 100644
index 0000000..8c59233
--- /dev/null
+++ b/src/ZrtpPacketDHPart.cpp
@@ -0,0 +1,98 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <libzrtpcpp/ZrtpPacketDHPart.h>
+
+ZrtpPacketDHPart::ZrtpPacketDHPart() {
+ DEBUGOUT((fprintf(stdout, "Creating DHPart packet without data and pkt type\n")));
+ initialize();
+}
+
+ZrtpPacketDHPart::ZrtpPacketDHPart(const char* pkt) {
+ DEBUGOUT((fprintf(stdout, "Creating DHPart packet without data\n")));
+ initialize();
+ setPubKeyType(pkt);
+}
+
+void ZrtpPacketDHPart::initialize() {
+
+ void* allocated = &data;
+ memset(allocated, 0, sizeof(data));
+
+ zrtpHeader = (zrtpPacketHeader_t *)&((DHPartPacket_t *)allocated)->hdr; // the standard header
+ DHPartHeader = (DHPart_t *)&((DHPartPacket_t *)allocated)->dhPart;
+ pv = ((uint8_t*)allocated) + sizeof(DHPartPacket_t); // point to the public key value
+
+ setZrtpId();
+}
+
+// The fixed numbers below are taken from ZRTP specification, chap 5.1.5
+void ZrtpPacketDHPart::setPubKeyType(const char* pkt) {
+ // Well - the algo type is only 4 char thus cast to int32 and compare
+ if (*(int32_t*)pkt == *(int32_t*)dh2k) {
+ dhLength = 256;
+ }
+ else if (*(int32_t*)pkt == *(int32_t*)dh3k) {
+ dhLength = 384;
+ }
+ else if (*(int32_t*)pkt == *(int32_t*)ec25) {
+ dhLength = 64;
+ }
+ else if (*(int32_t*)pkt == *(int32_t*)ec38) {
+ dhLength = 96;
+ }
+ else
+ return;
+
+ int length = sizeof(DHPartPacket_t) + dhLength + (2 * ZRTP_WORD_SIZE); // HMAC field is 2*ZRTP_WORD_SIZE
+ setLength(length / ZRTP_WORD_SIZE);
+}
+
+ZrtpPacketDHPart::ZrtpPacketDHPart(uint8_t *data) {
+ DEBUGOUT((fprintf(stdout, "Creating DHPart packet from data\n")));
+
+ zrtpHeader = (zrtpPacketHeader_t *)&((DHPartPacket_t *)data)->hdr; // the standard header
+ DHPartHeader = (DHPart_t *)&((DHPartPacket_t *)data)->dhPart;
+
+ int16_t len = getLength();
+ DEBUGOUT((fprintf(stdout, "DHPart length: %d\n", len)));
+ if (len == 85) {
+ dhLength = 256;
+ }
+ else if (len == 117) {
+ dhLength = 384;
+ }
+ else if (len == 37) {
+ dhLength = 64;
+ }
+ else if (len == 45) {
+ dhLength = 96;
+ }
+ else {
+ pv = NULL;
+ return;
+ }
+ pv = data + sizeof(DHPartPacket_t); // point to the public key value
+}
+
+ZrtpPacketDHPart::~ZrtpPacketDHPart() {
+ DEBUGOUT((fprintf(stdout, "Deleting DHPart packet: alloc: %x\n", allocated)));
+}
diff --git a/src/ZrtpPacketError.cpp b/src/ZrtpPacketError.cpp
new file mode 100644
index 0000000..a9d881e
--- /dev/null
+++ b/src/ZrtpPacketError.cpp
@@ -0,0 +1,46 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/* Copyright (C) 2006
+ *
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <libzrtpcpp/ZrtpPacketError.h>
+
+ZrtpPacketError::ZrtpPacketError() {
+ DEBUGOUT((fprintf(stdout, "Creating Error packet without data\n")));
+
+ zrtpHeader = &data.hdr; // the standard header
+ errorHeader = &data.error;
+
+ setZrtpId();
+ setLength((sizeof(ErrorPacket_t) / ZRTP_WORD_SIZE) - 1);
+ setMessageType((uint8_t*)ErrorMsg);
+}
+
+ZrtpPacketError::ZrtpPacketError(uint8_t *data) {
+ DEBUGOUT((fprintf(stdout, "Creating Error packet from data\n")));
+
+ allocated = NULL;
+ zrtpHeader = (zrtpPacketHeader_t *)&((ErrorPacket_t *)data)->hdr; // the standard header
+ errorHeader = (Error_t *)&((ErrorPacket_t *)data)->error;
+}
+
+ZrtpPacketError::~ZrtpPacketError() {
+ DEBUGOUT((fprintf(stdout, "Deleting Error packet: alloc: %x\n", allocated)));
+}
diff --git a/src/ZrtpPacketErrorAck.cpp b/src/ZrtpPacketErrorAck.cpp
new file mode 100644
index 0000000..3a30977
--- /dev/null
+++ b/src/ZrtpPacketErrorAck.cpp
@@ -0,0 +1,42 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <libzrtpcpp/ZrtpPacketErrorAck.h>
+
+ZrtpPacketErrorAck::ZrtpPacketErrorAck() {
+ DEBUGOUT((fprintf(stdout, "Creating ErrorAck packet without data\n")));
+
+ zrtpHeader = &data.hdr; // the standard header
+
+ setZrtpId();
+ setLength((sizeof (ErrorAckPacket_t) / ZRTP_WORD_SIZE) - 1);
+ setMessageType((uint8_t*)ErrorAckMsg);
+}
+
+ZrtpPacketErrorAck::ZrtpPacketErrorAck(uint8_t *data) {
+ DEBUGOUT((fprintf(stdout, "Creating ErrorAck packet from data\n")));
+
+ zrtpHeader = (zrtpPacketHeader_t *)&((ErrorAckPacket_t*)data)->hdr; // the standard header
+}
+
+ZrtpPacketErrorAck::~ZrtpPacketErrorAck() {
+ DEBUGOUT((fprintf(stdout, "Deleting ErrorAck packet: alloc: %x\n", allocated)));
+}
diff --git a/src/ZrtpPacketGoClear.cpp b/src/ZrtpPacketGoClear.cpp
new file mode 100644
index 0000000..247aec1
--- /dev/null
+++ b/src/ZrtpPacketGoClear.cpp
@@ -0,0 +1,45 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/* Copyright (C) 2006
+ *
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <libzrtpcpp/ZrtpPacketGoClear.h>
+
+ZrtpPacketGoClear::ZrtpPacketGoClear() {
+ DEBUGOUT((fprintf(stdout, "Creating GoClear packet without data\n")));
+
+ zrtpHeader = &data.hdr; // the standard header
+ clearHeader = &data.goClear;
+
+ setZrtpId();
+ setLength((sizeof(GoClearPacket_t) / ZRTP_WORD_SIZE) - 1);
+ setMessageType((uint8_t*)GoClearMsg);
+}
+
+ZrtpPacketGoClear::ZrtpPacketGoClear(uint8_t *data) {
+ DEBUGOUT((fprintf(stdout, "Creating GoClear packet from data\n")));
+
+ zrtpHeader = (zrtpPacketHeader_t *)&((GoClearPacket_t *)data)->hdr; // the standard header
+ clearHeader = (GoClear_t *)&((GoClearPacket_t *)data)->goClear;
+}
+
+ZrtpPacketGoClear::~ZrtpPacketGoClear() {
+ DEBUGOUT((fprintf(stdout, "Deleting GoClear packet: alloc: %x\n", allocated)));
+}
diff --git a/src/ZrtpPacketHello.cpp b/src/ZrtpPacketHello.cpp
new file mode 100644
index 0000000..17a82d2
--- /dev/null
+++ b/src/ZrtpPacketHello.cpp
@@ -0,0 +1,129 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <libzrtpcpp/ZrtpPacketHello.h>
+
+
+ZrtpPacketHello::ZrtpPacketHello() {
+ DEBUGOUT((fprintf(stdout, "Creating Hello packet without data\n")));
+}
+
+void ZrtpPacketHello::configureHello(ZrtpConfigure* config) {
+ // The NumSupported* data is in ZrtpTextData.h
+ nHash = config->getNumConfiguredAlgos(HashAlgorithm);
+ nCipher = config->getNumConfiguredAlgos(CipherAlgorithm);
+ nPubkey = config->getNumConfiguredAlgos(PubKeyAlgorithm);
+ nSas = config->getNumConfiguredAlgos(SasType);
+ nAuth = config->getNumConfiguredAlgos(AuthLength);
+
+ // length is fixed Header plus HMAC size (2*ZRTP_WORD_SIZE)
+ int32_t length = sizeof(HelloPacket_t) + (2 * ZRTP_WORD_SIZE);
+ length += nHash * ZRTP_WORD_SIZE;
+ length += nCipher * ZRTP_WORD_SIZE;
+ length += nPubkey * ZRTP_WORD_SIZE;
+ length += nSas * ZRTP_WORD_SIZE;
+ length += nAuth * ZRTP_WORD_SIZE;
+
+ // Don't change order of this sequence
+ oHash = sizeof(Hello_t);
+ oCipher = oHash + (nHash * ZRTP_WORD_SIZE);
+ oAuth = oCipher + (nCipher * ZRTP_WORD_SIZE);
+ oPubkey = oAuth + (nAuth * ZRTP_WORD_SIZE);
+ oSas = oPubkey + (nPubkey * ZRTP_WORD_SIZE);
+ oHmac = oSas + (nSas * ZRTP_WORD_SIZE); // offset to HMAC
+
+ void* allocated = &data;
+ memset(allocated, 0, sizeof(data));
+
+ zrtpHeader = (zrtpPacketHeader_t *)&((HelloPacket_t *)allocated)->hdr; // the standard header
+ helloHeader = (Hello_t *)&((HelloPacket_t *)allocated)->hello;
+
+ setZrtpId();
+
+ // minus 1 for CRC size
+ setLength(length / ZRTP_WORD_SIZE);
+ setMessageType((uint8_t*)HelloMsg);
+
+ setVersion((uint8_t*)zrtpVersion);
+
+ uint32_t lenField = nHash << 16;
+ for (int32_t i = 0; i < nHash; i++) {
+ AlgorithmEnum& hash = config->getAlgoAt(HashAlgorithm, i);
+ setHashType(i, (int8_t*)hash.getName());
+ }
+
+ lenField |= nCipher << 12;
+ for (int32_t i = 0; i < nCipher; i++) {
+ AlgorithmEnum& cipher = config->getAlgoAt(CipherAlgorithm, i);
+ setCipherType(i, (int8_t*)cipher.getName());
+ }
+
+ lenField |= nAuth << 8;
+ for (int32_t i = 0; i < nAuth; i++) {
+ AlgorithmEnum& length = config->getAlgoAt(AuthLength, i);
+ setAuthLen(i, (int8_t*)length.getName());
+ }
+
+ lenField |= nPubkey << 4;
+ for (int32_t i = 0; i < nPubkey; i++) {
+ AlgorithmEnum& pubKey = config->getAlgoAt(PubKeyAlgorithm, i);
+ setPubKeyType(i, (int8_t*)pubKey.getName());
+ }
+
+ lenField |= nSas;
+ for (int32_t i = 0; i < nSas; i++) {
+ AlgorithmEnum& sas = config->getAlgoAt(SasType, i);
+ setSasType(i, (int8_t*)sas.getName());
+ }
+ *((uint32_t*)&helloHeader->flags) = htonl(lenField);
+}
+
+ZrtpPacketHello::ZrtpPacketHello(uint8_t *data) {
+ DEBUGOUT((fprintf(stdout, "Creating Hello packet from data\n")));
+
+ zrtpHeader = (zrtpPacketHeader_t *)&((HelloPacket_t *)data)->hdr; // the standard header
+ helloHeader = (Hello_t *)&((HelloPacket_t *)data)->hello;
+
+ uint32_t t = *((uint32_t*)&helloHeader->flags);
+ uint32_t temp = ntohl(t);
+
+ nHash = (temp & (0xf << 16)) >> 16;
+ nHash &= 0x7; // restrict to max 7 algorithms
+ nCipher = (temp & (0xf << 12)) >> 12;
+ nCipher &= 0x7;
+ nAuth = (temp & (0xf << 8)) >> 8;
+ nAuth &= 0x7;
+ nPubkey = (temp & (0xf << 4)) >> 4;
+ nPubkey &= 0x7;
+ nSas = temp & 0xf;
+ nSas &= 0x7;
+
+ oHash = sizeof(Hello_t);
+ oCipher = oHash + (nHash * ZRTP_WORD_SIZE);
+ oAuth = oCipher + (nCipher * ZRTP_WORD_SIZE);
+ oPubkey = oAuth + (nAuth * ZRTP_WORD_SIZE);
+ oSas = oPubkey + (nPubkey * ZRTP_WORD_SIZE);
+ oHmac = oSas + (nSas * ZRTP_WORD_SIZE); // offset to HMAC
+}
+
+ZrtpPacketHello::~ZrtpPacketHello() {
+ DEBUGOUT((fprintf(stdout, "Deleting Hello packet: alloc: %x\n", allocated)));
+}
diff --git a/src/ZrtpPacketHelloAck.cpp b/src/ZrtpPacketHelloAck.cpp
new file mode 100644
index 0000000..2d752b7
--- /dev/null
+++ b/src/ZrtpPacketHelloAck.cpp
@@ -0,0 +1,44 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <libzrtpcpp/ZrtpPacketHelloAck.h>
+
+ZrtpPacketHelloAck::ZrtpPacketHelloAck() {
+ DEBUGOUT((fprintf(stdout, "Creating HelloAck packet without data\n")));
+
+ zrtpHeader = &data.hdr; // the standard header
+
+ setZrtpId();
+ setLength((sizeof(HelloAckPacket_t) / ZRTP_WORD_SIZE) - 1);
+ setMessageType((uint8_t*)HelloAckMsg);
+}
+
+ZrtpPacketHelloAck::ZrtpPacketHelloAck(uint8_t *data) {
+ DEBUGOUT((fprintf(stdout, "Creating HelloAck packet from data\n")));
+
+ zrtpHeader = (zrtpPacketHeader_t *)&((HelloAckPacket_t *)data)->hdr; // the standard header
+
+}
+
+ZrtpPacketHelloAck::~ZrtpPacketHelloAck() {
+ DEBUGOUT((fprintf(stdout, "Deleting HelloAck packet: alloc: %x\n", allocated)));
+}
+
diff --git a/src/ZrtpPacketPing.cpp b/src/ZrtpPacketPing.cpp
new file mode 100644
index 0000000..9a1f90f
--- /dev/null
+++ b/src/ZrtpPacketPing.cpp
@@ -0,0 +1,45 @@
+/*
+ Copyright (C) 2006-2009 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/>.
+*/
+
+/*
+ * @author: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <libzrtpcpp/ZrtpPacketPing.h>
+
+ZrtpPacketPing::ZrtpPacketPing() {
+ DEBUGOUT((fprintf(stdout, "Creating Ping packet without data\n")));
+
+ zrtpHeader = &data.hdr; // the standard header
+ pingHeader = &data.ping;
+
+ setZrtpId();
+ setLength((sizeof(PingPacket_t) / ZRTP_WORD_SIZE) - 1);
+ setMessageType((uint8_t*)PingMsg);
+ setVersion((uint8_t*)zrtpVersion);
+}
+
+ZrtpPacketPing::ZrtpPacketPing(uint8_t *data) {
+ DEBUGOUT((fprintf(stdout, "Creating Ping packet from data\n")));
+
+ zrtpHeader = (zrtpPacketHeader_t *)&((PingPacket_t*)data)->hdr; // the standard header
+ pingHeader = (Ping_t *)&((PingPacket_t *)data)->ping;
+}
+
+ZrtpPacketPing::~ZrtpPacketPing() {
+ DEBUGOUT((fprintf(stdout, "Deleting Ping packet: alloc: %x\n", allocated)));
+}
diff --git a/src/ZrtpPacketPingAck.cpp b/src/ZrtpPacketPingAck.cpp
new file mode 100644
index 0000000..2331640
--- /dev/null
+++ b/src/ZrtpPacketPingAck.cpp
@@ -0,0 +1,45 @@
+/*
+ Copyright (C) 2006-2009 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/>.
+*/
+
+/*
+ * @author: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <libzrtpcpp/ZrtpPacketPingAck.h>
+
+ZrtpPacketPingAck::ZrtpPacketPingAck() {
+ DEBUGOUT((fprintf(stdout, "Creating PingAck packet without data\n")));
+
+ zrtpHeader = &data.hdr; // the standard header
+ pingAckHeader = &data.pingAck;
+
+ setZrtpId();
+ setLength((sizeof(PingAckPacket_t) / ZRTP_WORD_SIZE) - 1);
+ setMessageType((uint8_t*)PingAckMsg);
+ setVersion((uint8_t*)zrtpVersion);
+}
+
+ZrtpPacketPingAck::ZrtpPacketPingAck(uint8_t *data) {
+ DEBUGOUT((fprintf(stdout, "Creating PingAck packet from data\n")));
+
+ zrtpHeader = (zrtpPacketHeader_t *)&((PingAckPacket_t*)data)->hdr; // the standard header
+ pingAckHeader = (PingAck_t *)&((PingAckPacket_t *)data)->pingAck;
+}
+
+ZrtpPacketPingAck::~ZrtpPacketPingAck() {
+ DEBUGOUT((fprintf(stdout, "Deleting PingAck packet: alloc: %x\n", allocated)));
+}
diff --git a/src/ZrtpPacketRelayAck.cpp b/src/ZrtpPacketRelayAck.cpp
new file mode 100644
index 0000000..6ff0c7a
--- /dev/null
+++ b/src/ZrtpPacketRelayAck.cpp
@@ -0,0 +1,42 @@
+/*
+ Copyright (C) 2006-20011 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <libzrtpcpp/ZrtpPacketRelayAck.h>
+
+ZrtpPacketRelayAck::ZrtpPacketRelayAck() {
+ DEBUGOUT((fprintf(stdout, "Creating RelayAck packet without data\n")));
+
+ zrtpHeader = &data.hdr; // the standard header
+
+ setZrtpId();
+ setLength((sizeof (RelayAckPacket_t) / ZRTP_WORD_SIZE) - 1);
+ setMessageType((uint8_t*)RelayAckMsg);
+}
+
+ZrtpPacketRelayAck::ZrtpPacketRelayAck(uint8_t *data) {
+ DEBUGOUT((fprintf(stdout, "Creating RelayAck packet from data\n")));
+
+ zrtpHeader = (zrtpPacketHeader_t *)&((RelayAckPacket_t*)data)->hdr; // the standard header
+}
+
+ZrtpPacketRelayAck::~ZrtpPacketRelayAck() {
+ DEBUGOUT((fprintf(stdout, "Deleting RelayAck packet: alloc: %x\n", allocated)));
+}
diff --git a/src/ZrtpPacketSASrelay.cpp b/src/ZrtpPacketSASrelay.cpp
new file mode 100644
index 0000000..d132e28
--- /dev/null
+++ b/src/ZrtpPacketSASrelay.cpp
@@ -0,0 +1,75 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <libzrtpcpp/ZrtpPacketSASrelay.h>
+
+ZrtpPacketSASrelay::ZrtpPacketSASrelay() {
+ DEBUGOUT((fprintf(stdout, "Creating SASrelay packet without data, no sl data\n")));
+ initialize();
+ setSignatureLength(0);
+}
+
+ZrtpPacketSASrelay::ZrtpPacketSASrelay(uint32_t sl) {
+ DEBUGOUT((fprintf(stdout, "Creating SASrelay packet without data\n")));
+ initialize();
+ setSignatureLength(sl);
+}
+
+void ZrtpPacketSASrelay::initialize() {
+ void* allocated = &data;
+ memset(allocated, 0, sizeof(data));
+
+ zrtpHeader = (zrtpPacketHeader_t *)&((SASrelayPacket_t *)allocated)->hdr; // the standard header
+ sasRelayHeader = (SASrelay_t *)&((SASrelayPacket_t *)allocated)->sasrelay;
+
+ setZrtpId();
+ setMessageType((uint8_t*)SasRelayMsg);
+}
+
+void ZrtpPacketSASrelay::setSignatureLength(uint32_t sl) {
+ sl &= 0x1ff; // make sure it is max 9 bits
+ int32_t length = sizeof(ConfirmPacket_t) + (sl * ZRTP_WORD_SIZE);
+ sasRelayHeader->sigLength = sl; // sigLength is a uint byte
+ if (sl & 0x100) { // check the 9th bit
+ sasRelayHeader->filler[1] = 1; // and set it if necessary
+ }
+ setLength(length / 4);
+}
+
+uint32_t ZrtpPacketSASrelay::getSignatureLength() {
+ uint32_t sl = sasRelayHeader->sigLength;
+ if (sasRelayHeader->filler[1] == 1) { // do we have a 9th bit
+ sl |= 0x100;
+ }
+ return sl;
+}
+
+ZrtpPacketSASrelay::ZrtpPacketSASrelay(uint8_t* data) {
+ DEBUGOUT((fprintf(stdout, "Creating SASrelay packet from data\n")));
+
+ allocated = NULL;
+ zrtpHeader = (zrtpPacketHeader_t *)&((SASrelayPacket_t *)data)->hdr; // the standard header
+ sasRelayHeader = (SASrelay_t *)&((SASrelayPacket_t *)data)->sasrelay;
+}
+
+ZrtpPacketSASrelay::~ZrtpPacketSASrelay() {
+ DEBUGOUT((fprintf(stdout, "Deleting SASrelay packet: alloc: %x\n", allocated)));
+}
diff --git a/src/ZrtpQueue.cpp b/src/ZrtpQueue.cpp
new file mode 100644
index 0000000..c9cd0e2
--- /dev/null
+++ b/src/ZrtpQueue.cpp
@@ -0,0 +1,847 @@
+/*
+ Copyright (C) 2006-2009 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <string>
+#include <stdio.h>
+
+#include <libzrtpcpp/ZrtpQueue.h>
+#include <libzrtpcpp/ZIDFile.h>
+#include <libzrtpcpp/ZRtp.h>
+#include <libzrtpcpp/ZrtpStateClass.h>
+#include <libzrtpcpp/ZrtpUserCallback.h>
+
+static TimeoutProvider<std::string, ost::ZrtpQueue*>* staticTimeoutProvider = NULL;
+
+NAMESPACE_COMMONCPP
+using namespace GnuZrtpCodes;
+
+ZrtpQueue::ZrtpQueue(uint32 size, RTPApplication& app) :
+ AVPQueue(size,app)
+{
+ init();
+}
+
+ZrtpQueue::ZrtpQueue(uint32 ssrc, uint32 size, RTPApplication& app) :
+ AVPQueue(ssrc,size,app)
+{
+ init();
+}
+
+void ZrtpQueue::init()
+{
+ zrtpUserCallback = NULL;
+ enableZrtp = false;
+ started = false;
+ mitmMode = false;
+ enableParanoidMode = false;
+ zrtpEngine = NULL;
+ senderZrtpSeqNo = 1;
+
+ clientIdString = clientId;
+ peerSSRC = 0;
+}
+
+ZrtpQueue::~ZrtpQueue() {
+
+ endQueue();
+ stopZrtp();
+
+ if (zrtpUserCallback != NULL) {
+ delete zrtpUserCallback;
+ zrtpUserCallback = NULL;
+ }
+}
+
+int32_t
+ZrtpQueue::initialize(const char *zidFilename, bool autoEnable, ZrtpConfigure* config)
+{
+ int32_t ret = 1;
+
+ synchEnter();
+
+ ZrtpConfigure* configOwn = NULL;
+ if (config == NULL) {
+ config = configOwn = new ZrtpConfigure();
+ config->setStandardConfig();
+ }
+ enableZrtp = autoEnable;
+
+ config->setParanoidMode(enableParanoidMode);
+
+ if (staticTimeoutProvider == NULL) {
+ staticTimeoutProvider = new TimeoutProvider<std::string, ZrtpQueue*>();
+ staticTimeoutProvider->start();
+ }
+ ZIDFile* zf = ZIDFile::getInstance();
+ if (!zf->isOpen()) {
+ std::string fname;
+ if (zidFilename == NULL) {
+ char *home = getenv("HOME");
+ std::string baseDir = (home != NULL) ? (std::string(home) + std::string("/."))
+ : std::string(".");
+ fname = baseDir + std::string("GNUZRTP.zid");
+ zidFilename = fname.c_str();
+ }
+ if (zf->open((char *)zidFilename) < 0) {
+ enableZrtp = false;
+ ret = -1;
+ }
+ }
+ if (ret > 0) {
+ const uint8_t* ownZid = zf->getZid();
+ zrtpEngine = new ZRtp((uint8_t*)ownZid, (ZrtpCallback*)this, clientIdString, config, mitmMode, signSas);
+ }
+ if (configOwn != NULL) {
+ delete configOwn;
+ }
+ synchLeave();
+ return ret;
+}
+
+void ZrtpQueue::startZrtp() {
+ if (zrtpEngine != NULL) {
+ zrtpEngine->startZrtpEngine();
+ started = true;
+ }
+}
+
+void ZrtpQueue::stopZrtp() {
+ if (zrtpEngine != NULL) {
+ delete zrtpEngine;
+ zrtpEngine = NULL;
+ started = false;
+ }
+}
+
+/*
+ * The takeInDataPacket implementation for ZRTPQueue.
+ */
+size_t
+ZrtpQueue::takeInDataPacket(void)
+{
+ InetHostAddress network_address;
+ tpport_t transport_port;
+
+ uint32 nextSize = (uint32)getNextDataPacketSize();
+ unsigned char* buffer = new unsigned char[nextSize];
+ int32 rtn = (int32)recvData(buffer, nextSize, network_address, transport_port);
+ if ( (rtn < 0) || ((uint32)rtn > getMaxRecvPacketSize()) ){
+ delete buffer;
+ return 0;
+ }
+
+ IncomingZRTPPkt* packet = NULL;
+ // check if this could be a real RTP/SRTP packet.
+ if ((*buffer & 0xf0) != 0x10) {
+ return (rtpDataPacket(buffer, rtn, network_address, transport_port));
+ }
+
+ // We assume all other packets are ZRTP packets here. Process
+ // if ZRTP processing is enabled. Because valid RTP packets are
+ // already handled we delete any packets here after processing.
+ if (enableZrtp && zrtpEngine != NULL) {
+ // Fixed header length + smallest ZRTP packet (includes CRC)
+ if ((unsigned)rtn < (12 + sizeof(HelloAckPacket_t))) // data too small, dismiss
+ return 0;
+
+ // Get CRC value into crc (see above how to compute the offset)
+ uint16_t temp = rtn - CRC_SIZE;
+ uint32_t crc = *(uint32_t*)(buffer + temp);
+ crc = ntohl(crc);
+
+ if (!zrtpCheckCksum(buffer, temp, crc)) {
+ delete buffer;
+ if (zrtpUserCallback != NULL)
+ zrtpUserCallback->showMessage(Warning, WarningCRCmismatch);
+ return 0;
+ }
+
+ packet = new IncomingZRTPPkt(buffer,rtn);
+
+ uint32 magic = packet->getZrtpMagic();
+
+ // Check if it is really a ZRTP packet, if not delete it and return 0
+ if (magic != ZRTP_MAGIC || zrtpEngine == NULL) {
+ delete packet;
+ return 0;
+ }
+ // cover the case if the other party sends _only_ ZRTP packets at the
+ // beginning of a session. Start ZRTP in this case as well.
+ if (!started) {
+ startZrtp();
+ }
+ // this now points beyond the undefined and length field.
+ // We need them, thus adjust
+ unsigned char* extHeader =
+ const_cast<unsigned char*>(packet->getHdrExtContent());
+ extHeader -= 4;
+
+ // store peer's SSRC, used when creating the CryptoContext
+ peerSSRC = packet->getSSRC();
+ zrtpEngine->processZrtpMessage(extHeader, peerSSRC);
+ }
+ delete packet;
+ return 0;
+}
+
+size_t
+ZrtpQueue::rtpDataPacket(unsigned char* buffer, int32 rtn, InetHostAddress network_address, tpport_t transport_port)
+{
+ // Special handling of padding to take care of encrypted content.
+ // In case of SRTP the padding length field is also encrypted, thus
+ // it gives a wrong length. Check and clear padding bit before
+ // creating the RTPPacket. Will be set and re-computed after a possible
+ // SRTP decryption.
+ uint8 padSet = (*buffer & 0x20);
+ if (padSet) {
+ *buffer = *buffer & ~0x20; // clear padding bit
+ }
+ // build a packet. It will link itself to its source
+ IncomingRTPPkt* packet =
+ new IncomingRTPPkt(buffer,rtn);
+
+ // Generic header validity check.
+ if ( !packet->isHeaderValid() ) {
+ delete packet;
+ return 0;
+ }
+
+ // Look for a CryptoContext for this packet's SSRC
+ CryptoContext* pcc = getInQueueCryptoContext(packet->getSSRC());
+
+ // If no crypto context is available for this SSRC but we are already in
+ // Secure state then create a CryptoContext for this SSRC.
+ // Assumption: every SSRC stream sent via this connection is secured
+ // _and_ uses the same crypto parameters.
+ if (pcc == NULL) {
+ pcc = getInQueueCryptoContext(0);
+ if (pcc != NULL) {
+ pcc = pcc->newCryptoContextForSSRC(packet->getSSRC(), 0, 0L);
+ if (pcc != NULL) {
+ pcc->deriveSrtpKeys(0);
+ setInQueueCryptoContext(pcc);
+ }
+ }
+ }
+ // If no crypto context: then either ZRTP is off or in early state
+ // If crypto context is available then unprotect data here. If an error
+ // occurs report the error and discard the packet.
+ if (pcc != NULL) {
+ int32 ret;
+ if ((ret = packet->unprotect(pcc)) < 0) {
+ if (!onSRTPPacketError(*packet, ret)) {
+ delete packet;
+ return 0;
+ }
+ }
+ if (started && zrtpEngine->inState(WaitConfAck)) {
+ zrtpEngine->conf2AckSecure();
+ }
+ }
+
+ // virtual for profile-specific validation and processing.
+ if (!onRTPPacketRecv(*packet) ) {
+ delete packet;
+ return 0;
+ }
+ if (padSet) {
+ packet->reComputePayLength(true);
+ }
+ // get time of arrival
+ struct timeval recvtime;
+ gettimeofday(&recvtime,NULL);
+
+ bool source_created;
+ SyncSourceLink* sourceLink =
+ getSourceBySSRC(packet->getSSRC(),source_created);
+ SyncSource* s = sourceLink->getSource();
+ if ( source_created ) {
+ // Set data transport address.
+ setDataTransportPort(*s,transport_port);
+ // Network address is assumed to be the same as the control one
+ setNetworkAddress(*s,network_address);
+ sourceLink->initStats();
+ // First packet arrival time.
+ sourceLink->setInitialDataTime(recvtime);
+ sourceLink->setProbation(getMinValidPacketSequence());
+ if ( sourceLink->getHello() )
+ onNewSyncSource(*s);
+ }
+ else if ( 0 == s->getDataTransportPort() ) {
+ // Test if RTCP packets had been received but this is the
+ // first data packet from this source.
+ setDataTransportPort(*s,transport_port);
+ }
+
+ // Before inserting in the queue,
+ // 1) check for collisions and loops. If the packet cannot be
+ // assigned to a source, it will be rejected.
+ // 2) check the source is a sufficiently well known source
+ // TODO: also check CSRC identifiers.
+ if (checkSSRCInIncomingRTPPkt(*sourceLink, source_created,
+ network_address, transport_port) &&
+ recordReception(*sourceLink,*packet,recvtime) ) {
+ // now the packet link is linked in the queues
+ IncomingRTPPktLink* packetLink = new IncomingRTPPktLink(packet, sourceLink, recvtime,
+ packet->getTimestamp() - sourceLink->getInitialDataTimestamp(),
+ NULL,NULL,NULL,NULL);
+ insertRecvPacket(packetLink);
+ } else {
+ // must be discarded due to collision or loop or
+ // invalid source
+ delete packet;
+ return 0;
+ }
+ // Start the ZRTP engine after we got a at least one RTP packet and
+ // sent some as well or we are in multi-stream mode.
+ if (!started && enableZrtp) {
+ startZrtp();
+ }
+ return rtn;
+}
+
+bool
+ZrtpQueue::onSRTPPacketError(IncomingRTPPkt& pkt, int32 errorCode)
+{
+ if (errorCode == -1) {
+ sendInfo(Warning, WarningSRTPauthError);
+ }
+ else {
+ sendInfo(Warning, WarningSRTPreplayError);
+ }
+ return false;
+}
+
+
+void
+ZrtpQueue::putData(uint32 stamp, const unsigned char* data, size_t len)
+{
+ OutgoingDataQueue::putData(stamp, data, len);
+}
+
+
+void
+ZrtpQueue::sendImmediate(uint32 stamp, const unsigned char* data, size_t len)
+{
+ OutgoingDataQueue::sendImmediate(stamp, data, len);
+}
+
+
+/*
+ * Here the callback methods required by the ZRTP implementation
+ */
+int32_t ZrtpQueue::sendDataZRTP(const unsigned char *data, int32_t length) {
+
+ OutgoingZRTPPkt* packet = new OutgoingZRTPPkt(data, length);
+
+ packet->setSSRC(getLocalSSRC());
+
+ packet->setSeqNum(senderZrtpSeqNo++);
+
+ /*
+ * Compute the ZRTP CRC over the full ZRTP packet. Thus include
+ * the fixed packet header into the calculation.
+ */
+ uint16_t temp = packet->getRawPacketSize() - CRC_SIZE;
+ uint8_t* pt = (uint8_t*)packet->getRawPacket();
+ uint32_t crc = zrtpGenerateCksum(pt, temp);
+ // convert and store CRC in crc field of ZRTP packet.
+ crc = zrtpEndCksum(crc);
+
+ // advance pointer to CRC storage
+ pt += temp;
+ *(uint32_t*)pt = htonl(crc);
+
+ dispatchImmediate(packet);
+ delete packet;
+
+ return 1;
+}
+
+bool ZrtpQueue::srtpSecretsReady(SrtpSecret_t* secrets, EnableSecurity part)
+{
+ CryptoContext* recvCryptoContext;
+ CryptoContext* senderCryptoContext;
+ CryptoContextCtrl* recvCryptoContextCtrl;
+ CryptoContextCtrl* senderCryptoContextCtrl;
+
+ int cipher;
+ int authn;
+ int authKeyLen;
+
+ if (secrets->authAlgorithm == Sha1) {
+ authn = SrtpAuthenticationSha1Hmac;
+ authKeyLen = 20;
+ }
+
+ if (secrets->authAlgorithm == Skein) {
+ authn = SrtpAuthenticationSkeinHmac;
+ authKeyLen = 32;
+ }
+
+ if (secrets->symEncAlgorithm == Aes)
+ cipher = SrtpEncryptionAESCM;
+
+ if (secrets->symEncAlgorithm == TwoFish)
+ cipher = SrtpEncryptionTWOCM;
+
+ if (part == ForSender) {
+ // To encrypt packets: intiator uses initiator keys,
+ // responder uses responder keys
+ // Create a "half baked" crypto context first and store it. This is
+ // the main crypto context for the sending part of the connection.
+ if (secrets->role == Initiator) {
+ senderCryptoContext = new CryptoContext(
+ 0,
+ 0,
+ 0L, // keyderivation << 48,
+ cipher, // encryption algo
+ authn, // authtentication algo
+ (unsigned char*)secrets->keyInitiator, // Master Key
+ secrets->initKeyLen / 8, // Master Key length
+ (unsigned char*)secrets->saltInitiator, // Master Salt
+ secrets->initSaltLen / 8, // Master Salt length
+ secrets->initKeyLen / 8, // encryption keyl
+ authKeyLen, // authentication key len
+ secrets->initSaltLen / 8, // session salt len
+ secrets->srtpAuthTagLen / 8); // authentication tag lenA
+ senderCryptoContextCtrl = new CryptoContextCtrl(0,
+ cipher, // encryption algo
+ authn, // authtication algo
+ (unsigned char*)secrets->keyInitiator, // Master Key
+ secrets->initKeyLen / 8, // Master Key length
+ (unsigned char*)secrets->saltInitiator, // Master Salt
+ secrets->initSaltLen / 8, // Master Salt length
+ secrets->initKeyLen / 8, // encryption keyl
+ authKeyLen, // authentication key len
+ secrets->initSaltLen / 8, // session salt len
+ secrets->srtpAuthTagLen / 8); // authentication tag len
+ }
+ else {
+ senderCryptoContext = new CryptoContext(
+ 0,
+ 0,
+ 0L, // keyderivation << 48,
+ cipher, // encryption algo
+ authn, // authtentication algo
+ (unsigned char*)secrets->keyResponder, // Master Key
+ secrets->respKeyLen / 8, // Master Key length
+ (unsigned char*)secrets->saltResponder, // Master Salt
+ secrets->respSaltLen / 8, // Master Salt length
+ secrets->respKeyLen / 8, // encryption keyl
+ authKeyLen, // authentication key len
+ secrets->respSaltLen / 8, // session salt len
+ secrets->srtpAuthTagLen / 8); // authentication tag len
+ senderCryptoContextCtrl = new CryptoContextCtrl(0,
+ cipher, // encryption algo
+ authn, // authtication algo
+ (unsigned char*)secrets->keyResponder, // Master Key
+ secrets->respKeyLen / 8, // Master Key length
+ (unsigned char*)secrets->saltResponder, // Master Salt
+ secrets->respSaltLen / 8, // Master Salt length
+ secrets->respKeyLen / 8, // encryption keyl
+ authKeyLen, // authentication key len
+ secrets->respSaltLen / 8, // session salt len
+ secrets->srtpAuthTagLen / 8); // authentication tag len
+ }
+ if (senderCryptoContext == NULL) {
+ return false;
+ }
+ // Insert the Crypto templates (SSRC == 0) into the queue. When we send
+ // the first RTP or RTCP packet the real crypto context will be created.
+ // Refer to putData(), sendImmediate() in ccrtp's outqueue.cpp and
+ // takeinControlPacket() in ccrtp's control.cpp.
+ //
+ setOutQueueCryptoContext(senderCryptoContext);
+ setOutQueueCryptoContextCtrl(senderCryptoContextCtrl);
+ }
+ if (part == ForReceiver) {
+ // To decrypt packets: intiator uses responder keys,
+ // responder initiator keys
+ // See comment above.
+ if (secrets->role == Initiator) {
+ recvCryptoContext = new CryptoContext(
+ 0,
+ 0,
+ 0L, // keyderivation << 48,
+ cipher, // encryption algo
+ authn, // authtentication algo
+ (unsigned char*)secrets->keyResponder, // Master Key
+ secrets->respKeyLen / 8, // Master Key length
+ (unsigned char*)secrets->saltResponder, // Master Salt
+ secrets->respSaltLen / 8, // Master Salt length
+ secrets->respKeyLen / 8, // encryption keyl
+ authKeyLen, // authentication key len
+ secrets->respSaltLen / 8, // session salt len
+ secrets->srtpAuthTagLen / 8); // authentication tag len
+ recvCryptoContextCtrl = new CryptoContextCtrl(0,
+ cipher, // encryption algo
+ authn, // authtication algo
+ (unsigned char*)secrets->keyResponder, // Master Key
+ secrets->respKeyLen / 8, // Master Key length
+ (unsigned char*)secrets->saltResponder, // Master Salt
+ secrets->respSaltLen / 8, // Master Salt length
+ secrets->respKeyLen / 8, // encryption keyl
+ authKeyLen, // authentication key len
+ secrets->respSaltLen / 8, // session salt len
+ secrets->srtpAuthTagLen / 8); // authentication tag len
+
+ }
+ else {
+ recvCryptoContext = new CryptoContext(
+ 0,
+ 0,
+ 0L, // keyderivation << 48,
+ cipher, // encryption algo
+ authn, // authtentication algo
+ (unsigned char*)secrets->keyInitiator, // Master Key
+ secrets->initKeyLen / 8, // Master Key length
+ (unsigned char*)secrets->saltInitiator, // Master Salt
+ secrets->initSaltLen / 8, // Master Salt length
+ secrets->initKeyLen / 8, // encryption keyl
+ authKeyLen, // authentication key len
+ secrets->initSaltLen / 8, // session salt len
+ secrets->srtpAuthTagLen / 8); // authentication tag len
+ recvCryptoContextCtrl = new CryptoContextCtrl(0,
+ cipher, // encryption algo
+ authn, // authtication algo
+ (unsigned char*)secrets->keyInitiator, // Master Key
+ secrets->initKeyLen / 8, // Master Key length
+ (unsigned char*)secrets->saltInitiator, // Master Salt
+ secrets->initSaltLen / 8, // Master Salt length
+ secrets->initKeyLen / 8, // encryption keyl
+ authKeyLen, // authentication key len
+ secrets->initSaltLen / 8, // session salt len
+ secrets->srtpAuthTagLen / 8); // authentication tag len
+ }
+ if (recvCryptoContext == NULL) {
+ return false;
+ }
+ // Insert the Crypto templates (SSRC == 0) into the queue. When we receive
+ // the first RTP or RTCP packet the real crypto context will be created.
+ // Refer to rtpDataPacket() above and takeinControlPacket in ccrtp's control.cpp.
+ //
+ setInQueueCryptoContext(recvCryptoContext);
+ setInQueueCryptoContextCtrl(recvCryptoContextCtrl);
+ }
+ return true;
+}
+
+void ZrtpQueue::srtpSecretsOn(std::string c, std::string s, bool verified)
+{
+
+ if (zrtpUserCallback != NULL) {
+ zrtpUserCallback->secureOn(c);
+ if (!s.empty()) {
+ zrtpUserCallback->showSAS(s, verified);
+ }
+ }
+}
+
+void ZrtpQueue::srtpSecretsOff(EnableSecurity part) {
+ if (part == ForSender) {
+ removeOutQueueCryptoContext(NULL);
+ removeOutQueueCryptoContextCtrl(NULL);
+ }
+ if (part == ForReceiver) {
+ removeInQueueCryptoContext(NULL);
+ removeInQueueCryptoContextCtrl(NULL);
+ }
+ if (zrtpUserCallback != NULL) {
+ zrtpUserCallback->secureOff();
+ }
+}
+
+int32_t ZrtpQueue::activateTimer(int32_t time) {
+ std::string s("ZRTP");
+ if (staticTimeoutProvider != NULL) {
+ staticTimeoutProvider->requestTimeout(time, this, s);
+ }
+ return 1;
+}
+
+int32_t ZrtpQueue::cancelTimer() {
+ std::string s("ZRTP");
+ if (staticTimeoutProvider != NULL) {
+ staticTimeoutProvider->cancelRequest(this, s);
+ }
+ return 1;
+}
+
+void ZrtpQueue::handleTimeout(const std::string &c) {
+ if (zrtpEngine != NULL) {
+ zrtpEngine->processTimeout();
+ }
+}
+
+void ZrtpQueue::handleGoClear()
+{
+ fprintf(stderr, "Need to process a GoClear message!");
+}
+
+void ZrtpQueue::sendInfo(MessageSeverity severity, int32_t subCode) {
+ if (zrtpUserCallback != NULL) {
+ zrtpUserCallback->showMessage(severity, subCode);
+ }
+}
+
+void ZrtpQueue::zrtpNegotiationFailed(MessageSeverity severity, int32_t subCode) {
+ if (zrtpUserCallback != NULL) {
+ zrtpUserCallback->zrtpNegotiationFailed(severity, subCode);
+ }
+}
+
+void ZrtpQueue::zrtpNotSuppOther() {
+ if (zrtpUserCallback != NULL) {
+ zrtpUserCallback->zrtpNotSuppOther();
+ }
+}
+
+void ZrtpQueue::synchEnter() {
+ synchLock.enter();
+}
+
+void ZrtpQueue::synchLeave() {
+ synchLock.leave();
+}
+
+void ZrtpQueue::zrtpAskEnrollment(GnuZrtpCodes::InfoEnrollment info) {
+ if (zrtpUserCallback != NULL) {
+ zrtpUserCallback->zrtpAskEnrollment(info);
+ }
+}
+
+void ZrtpQueue::zrtpInformEnrollment(GnuZrtpCodes::InfoEnrollment info) {
+ if (zrtpUserCallback != NULL) {
+ zrtpUserCallback->zrtpInformEnrollment(info);
+ }
+}
+
+void ZrtpQueue::signSAS(uint8_t* sasHash) {
+ if (zrtpUserCallback != NULL) {
+ zrtpUserCallback->signSAS(sasHash);
+ }
+}
+
+bool ZrtpQueue::checkSASSignature(uint8_t* sasHash) {
+ if (zrtpUserCallback != NULL) {
+ return zrtpUserCallback->checkSASSignature(sasHash);
+ }
+ return false;
+}
+
+void ZrtpQueue::setEnableZrtp(bool onOff) {
+ enableZrtp = onOff;
+}
+
+bool ZrtpQueue::isEnableZrtp() {
+ return enableZrtp;
+}
+
+void ZrtpQueue::SASVerified() {
+ if (zrtpEngine != NULL)
+ zrtpEngine->SASVerified();
+}
+
+void ZrtpQueue::resetSASVerified() {
+ if (zrtpEngine != NULL)
+ zrtpEngine->resetSASVerified();
+}
+
+void ZrtpQueue::goClearOk() { }
+
+void ZrtpQueue::requestGoClear() { }
+
+void ZrtpQueue::setAuxSecret(uint8* data, int32_t length) {
+ if (zrtpEngine != NULL)
+ zrtpEngine->setAuxSecret(data, length);
+}
+
+void ZrtpQueue::setUserCallback(ZrtpUserCallback* ucb) {
+ zrtpUserCallback = ucb;
+}
+
+void ZrtpQueue::setClientId(std::string id) {
+ clientIdString = id;
+}
+
+std::string ZrtpQueue::getHelloHash() {
+ if (zrtpEngine != NULL)
+ return zrtpEngine->getHelloHash();
+ else
+ return std::string();
+}
+
+std::string ZrtpQueue::getPeerHelloHash() {
+ if (zrtpEngine != NULL)
+ return zrtpEngine->getPeerHelloHash();
+ else
+ return std::string();
+}
+
+std::string ZrtpQueue::getMultiStrParams() {
+ if (zrtpEngine != NULL)
+ return zrtpEngine->getMultiStrParams();
+ else
+ return std::string();
+}
+
+void ZrtpQueue::setMultiStrParams(std::string parameters) {
+ if (zrtpEngine != NULL)
+ zrtpEngine->setMultiStrParams(parameters);
+}
+
+bool ZrtpQueue::isMultiStream() {
+ if (zrtpEngine != NULL)
+ return zrtpEngine->isMultiStream();
+ return false;
+}
+
+bool ZrtpQueue::isMultiStreamAvailable() {
+ if (zrtpEngine != NULL)
+ return zrtpEngine->isMultiStreamAvailable();
+ return false;
+}
+
+void ZrtpQueue::acceptEnrollment(bool accepted) {
+ if (zrtpEngine != NULL)
+ zrtpEngine->acceptEnrollment(accepted);
+}
+
+std::string ZrtpQueue::getSasType() {
+ if (zrtpEngine != NULL)
+ return zrtpEngine->getSasType();
+ else
+ return NULL;
+}
+
+uint8_t* ZrtpQueue::getSasHash() {
+ if (zrtpEngine != NULL)
+ return zrtpEngine->getSasHash();
+ else
+ return NULL;
+}
+
+bool ZrtpQueue::sendSASRelayPacket(uint8_t* sh, std::string render) {
+
+ if (zrtpEngine != NULL)
+ return zrtpEngine->sendSASRelayPacket(sh, render);
+ else
+ return false;
+}
+
+bool ZrtpQueue::isMitmMode() {
+ return mitmMode;
+}
+
+void ZrtpQueue::setMitmMode(bool mitmMode) {
+ this->mitmMode = mitmMode;
+}
+
+bool ZrtpQueue::isEnrollmentMode() {
+ if (zrtpEngine != NULL)
+ return zrtpEngine->isEnrollmentMode();
+ else
+ return false;
+}
+
+void ZrtpQueue::setEnrollmentMode(bool enrollmentMode) {
+ if (zrtpEngine != NULL)
+ zrtpEngine->setEnrollmentMode(enrollmentMode);
+}
+
+void ZrtpQueue::setParanoidMode(bool yesNo) {
+ enableParanoidMode = yesNo;
+}
+
+bool ZrtpQueue::isParanoidMode() {
+ return enableParanoidMode;
+}
+
+bool ZrtpQueue::isPeerEnrolled() {
+ if (zrtpEngine != NULL)
+ return zrtpEngine->isPeerEnrolled();
+ else
+ return false;
+}
+
+void ZrtpQueue::setSignSas(bool sasSignMode) {
+ signSas = sasSignMode;
+}
+
+bool ZrtpQueue::setSignatureData(uint8* data, int32 length) {
+ if (zrtpEngine != NULL)
+ return zrtpEngine->setSignatureData(data, length);
+ return 0;
+}
+
+const uint8* ZrtpQueue::getSignatureData() {
+ if (zrtpEngine != NULL)
+ return zrtpEngine->getSignatureData();
+ return 0;
+}
+
+int32 ZrtpQueue::getSignatureLength() {
+ if (zrtpEngine != NULL)
+ return zrtpEngine->getSignatureLength();
+ return 0;
+}
+
+int32 ZrtpQueue::getPeerZid(uint8* data) {
+ if (data == NULL)
+ return 0;
+
+ if (zrtpEngine != NULL)
+ return zrtpEngine->getPeerZid(data);
+
+ return 0;
+}
+
+IncomingZRTPPkt::IncomingZRTPPkt(const unsigned char* const block, size_t len) :
+ IncomingRTPPkt(block,len) {
+}
+
+uint32 IncomingZRTPPkt::getZrtpMagic() const {
+ return ntohl(getHeader()->timestamp);
+}
+
+uint32 IncomingZRTPPkt::getSSRC() const {
+ return ntohl(getHeader()->sources[0]);
+}
+
+OutgoingZRTPPkt::OutgoingZRTPPkt(
+ const unsigned char* const hdrext, uint32 hdrextlen) :
+ OutgoingRTPPkt(NULL, 0, hdrext, hdrextlen, NULL ,0, 0, NULL)
+{
+ getHeader()->version = 0;
+ getHeader()->timestamp = htonl(ZRTP_MAGIC);
+}
+
+END_NAMESPACE
+
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-default-style: ellemtel
+ * c-basic-offset: 4
+ * End:
+ */
+
diff --git a/src/ZrtpStateClass.cpp b/src/ZrtpStateClass.cpp
new file mode 100644
index 0000000..cff9c6e
--- /dev/null
+++ b/src/ZrtpStateClass.cpp
@@ -0,0 +1,1473 @@
+/*
+ Copyright (C) 2006-2008 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/>.
+*/
+
+/**
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <iostream>
+#include <cstdlib>
+#include <ctype.h>
+
+#include <libzrtpcpp/ZRtp.h>
+#include <libzrtpcpp/ZrtpStateClass.h>
+
+using namespace std;
+using namespace GnuZrtpCodes;
+
+state_t states[numberOfStates] = {
+ {Initial, &ZrtpStateClass::evInitial },
+ {Detect, &ZrtpStateClass::evDetect },
+ {AckDetected, &ZrtpStateClass::evAckDetected },
+ {AckSent, &ZrtpStateClass::evAckSent },
+ {WaitCommit, &ZrtpStateClass::evWaitCommit },
+ {CommitSent, &ZrtpStateClass::evCommitSent },
+ {WaitDHPart2, &ZrtpStateClass::evWaitDHPart2 },
+ {WaitConfirm1, &ZrtpStateClass::evWaitConfirm1 },
+ {WaitConfirm2, &ZrtpStateClass::evWaitConfirm2 },
+ {WaitConfAck, &ZrtpStateClass::evWaitConfAck },
+ {WaitClearAck, &ZrtpStateClass::evWaitClearAck },
+ {SecureState, &ZrtpStateClass::evSecureState },
+ {WaitErrorAck, &ZrtpStateClass::evWaitErrorAck }
+};
+
+
+ZrtpStateClass::ZrtpStateClass(ZRtp *p) {
+ parent = p;
+ secSubstate = Normal;
+ engine = new ZrtpStates(states, numberOfStates, Initial);
+
+ commitPkt = NULL;
+ multiStream = false;
+
+ // Set up timers according to ZRTP spec
+ T1.start = 50;
+ T1.maxResend = 20;
+ T1.capping = 200;
+
+ T2.start = 150;
+ T2.maxResend = 10;
+ T2.capping = 600;
+}
+
+ZrtpStateClass::~ZrtpStateClass(void) {
+
+ // If not in Initial state: close the protocol engine
+ // before destroying it. This will free pending packets
+ // if necessary.
+ if (!inState(Initial)) {
+ Event_t ev;
+
+ cancelTimer();
+ ev.type = ZrtpClose;
+ event = &ev;
+ engine->processEvent(*this);
+ }
+ delete engine;
+}
+
+void ZrtpStateClass::processEvent(Event_t *ev) {
+
+ event = ev;
+ char *msg, first, middle, last;
+ uint8_t *pkt;
+
+ parent->synchEnter();
+
+ if (event->type == ZrtpPacket) {
+ pkt = event->packet;
+ msg = (char *)pkt + 4;
+ first = tolower(*msg);
+ middle = tolower(*(msg+4));
+ last = tolower(*(msg+7));
+
+ // Check if this is an Error packet.
+ if (first == 'e' && middle =='r' && last == ' ') {
+ /*
+ * Process a received Error packet.
+ *
+ * In any case stop timer to prevent resending packets.
+ * Use callback method to prepare and get an ErrorAck packet.
+ * Modify event type to "ErrorPkt" and hand it over to current
+ * state for further processing.
+ */
+ cancelTimer();
+ ZrtpPacketError epkt(pkt);
+ ZrtpPacketErrorAck* eapkt = parent->prepareErrorAck(&epkt);
+ parent->sendPacketZRTP(static_cast<ZrtpPacketBase *>(eapkt));
+ event->type = ErrorPkt;
+ }
+ else if (first == 'p' && middle == ' ' && last == ' ') {
+ ZrtpPacketPing ppkt(pkt);
+ ZrtpPacketPingAck* ppktAck = parent->preparePingAck(&ppkt);
+ if (ppktAck != NULL) { // ACK only to valid PING packet, otherwise ignore it
+ parent->sendPacketZRTP(static_cast<ZrtpPacketBase *>(ppktAck));
+ }
+ parent->synchLeave();
+ return;
+ }
+ else if (first == 's' && last == 'y') {
+ uint32_t errorCode = 0;
+ ZrtpPacketSASrelay* srly = new ZrtpPacketSASrelay(pkt);
+ ZrtpPacketRelayAck* rapkt = parent->prepareRelayAck(srly, &errorCode);
+ parent->sendPacketZRTP(static_cast<ZrtpPacketBase *>(rapkt));
+ parent->synchLeave();
+ return;
+ }
+
+ }
+ /*
+ * Shut down protocol state engine: cancel outstanding timer, further
+ * processing in current state.
+ */
+ else if (event->type == ZrtpClose) {
+ cancelTimer();
+ }
+ engine->processEvent(*this);
+ parent->synchLeave();
+}
+
+
+void ZrtpStateClass::evInitial(void) {
+ DEBUGOUT((cout << "Checking for match in Initial.\n"));
+
+ if (event->type == ZrtpInitial) {
+ ZrtpPacketHello* hello = parent->prepareHello();
+
+ // remember packet for easy resend in case timer triggers
+ sentPacket = static_cast<ZrtpPacketBase *>(hello);
+
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ return;
+ }
+ if (startTimer(&T1) <= 0) {
+ timerFailed(SevereNoTimer); // returns to state Initial
+ return;
+ }
+ nextState(Detect);
+ }
+}
+
+/*
+ * Detect state.
+ *
+ * When in this state the protocol engine sent an initial Hello packet
+ * to the peer.
+ *
+ * When entering this state transition function then:
+ * - Assume Initiator mode, mode may change later on peer reaction
+ * - Instance variable sentPacket contains the sent Hello packet
+ * - Hello timer T1 may be active. This is the case if the other peer
+ * has prepared its RTP session and answers our Hello packets nearly
+ * immediately, i.e. before the Hello timeout counter expires. If the
+ * other peer does not send a Hello during this time the state engine
+ * reports "other peer does not support ZRTP" but stays
+ * in state Detect with no active timer (passiv mode). Staying in state
+ * Detect allows another peer to start its detect phase any time later.
+ *
+ * This restart capability is the reason why we use "startTimer(&T1)" in
+ * case we received a Hello packet from another peer. This effectively
+ * restarts the Hello timeout counter.
+ *
+ * In this state we also handle ZrtpInitialize event. This forces a
+ * restart of ZRTP discovery if an application calls ZrtpQueue#startZrtp
+ * again. This may happen after a previous discovery phase were not
+ * successful.
+ *
+ * Usually applications use some sort of signaling protocol, for example
+ * SIP, to negotiate the RTP parameters. Thus the RTP sessions setup is
+ * fairly sychronized and thus also the ZRTP detection phase. Applications
+ * that use some other ways to setup the RTP sessions this restart capability
+ * comes in handy because no RTP setup sychronization is necessary.
+ *
+ * Possible events in this state are:
+ * - timeout for sent Hello packet: causes a resend check and
+ * repeat sending of Hello packet
+ * - received a HelloAck: stop active timer, prepare and send Hello packet,
+ * switch to state AckDeteced.
+ * - received a Hello: stop active timer, send HelloAck, prepare Commit
+ * packet, switch to state AckSent.
+ *
+ */
+void ZrtpStateClass::evDetect(void) {
+
+ DEBUGOUT((cout << "Checking for match in Detect.\n"));
+
+ char *msg, first, last;
+ uint8_t *pkt;
+ uint32_t errorCode = 0;
+
+ /*
+ * First check the general event type, then discrimnate
+ * the real event.
+ */
+ if (event->type == ZrtpPacket) {
+ pkt = event->packet;
+ msg = (char *)pkt + 4;
+
+ first = tolower(*msg);
+ last = tolower(*(msg+7));
+ /*
+ * HelloAck:
+ * - our peer acknowledged our Hello packet, we have not seen the peer's Hello yet
+ * - cancel timer T1 to stop resending Hello
+ * - switch to state AckDetected, wait for peer's Hello (F3)
+ */
+ if (first == 'h' && last =='k') {
+ cancelTimer();
+ sentPacket = NULL;
+ nextState(AckDetected);
+ return;
+ }
+ /*
+ * Hello:
+ * - send HelloAck packet to acknowledge the received Hello packet
+ * - use received Hello packet to prepare own Commit packet. We need to
+ * do it at this point because we need the hash value computed from
+ * peer's Hello packet. Follwing states my use the prepared Commit.
+ * - switch to new state AckSent which sends own Hello packet until
+ * peer acknowledges this
+ * - Don't clear sentPacket, points to Hello
+ */
+ if (first == 'h' && last ==' ') {
+ cancelTimer();
+ ZrtpPacketHelloAck* helloAck = parent->prepareHelloAck();
+
+ if (!parent->sendPacketZRTP(static_cast<ZrtpPacketBase *>(helloAck))) {
+ parent->zrtpNegotiationFailed(Severe, SevereCannotSend);
+ return;
+ }
+ // Use peer's Hello packet to create my commit packet, store it
+ // for possible later usage in state AckSent
+ ZrtpPacketHello hpkt(pkt);
+ commitPkt = parent->prepareCommit(&hpkt, &errorCode);
+
+ nextState(AckSent);
+ if (commitPkt == NULL) {
+ sendErrorPacket(errorCode); // switches to Error state
+ return;
+ }
+ if (startTimer(&T1) <= 0) { // restart own Hello timer/counter
+ timerFailed(SevereNoTimer); // returns to state Initial
+ }
+ T1.maxResend = 60; // more retries to extend time, see chap. 6
+ }
+ return; // unknown packet for this state - Just ignore it
+ }
+ // Timer event triggered - this is Timer T1 to resend Hello
+ else if (event->type == Timer) {
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ return;
+ }
+ if (nextTimer(&T1) <= 0) {
+ commitPkt = NULL;
+ parent->zrtpNotSuppOther();
+ nextState(Detect);
+ }
+ }
+ // If application call zrtpStart() to restart discovery
+ else if (event->type == ZrtpInitial) {
+ cancelTimer();
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ return;
+ }
+ if (startTimer(&T1) <= 0) {
+ timerFailed(SevereNoTimer); // returns to state Initial
+ }
+ }
+ else { // unknown Event type for this state (covers Error and ZrtpClose)
+ if (event->type != ZrtpClose) {
+ parent->zrtpNegotiationFailed(Severe, SevereProtocolError);
+ }
+ sentPacket = NULL;
+ nextState(Initial);
+ }
+}
+
+/*
+ * AckSent state.
+ *
+ * The protocol engine got a Hello packet from peer and answered with a
+ * HelloAck response. According to the protocol we must also send a
+ * Hello after HelloAck (refer to figure 1 in ZRTP RFC xxxx, message
+ * HelloACK (F2) must be followed by Hello (F3)). We use the timeout in
+ * this state to send the required Hello (F3).
+ *
+ * Our peer must acknowledge the Hello with HelloAck. In earlier versions
+ * also a Commit was a valid packet thus the code covers this.
+ * Figure 1 in the RFC shows the HelloAck, chapter 7 states that a Commit
+ * may be send to acknowledge Hello. There is one constraint when using a Commit to
+ * acknowledge Hello: refer to chapter 4.1 that requires that both parties
+ * have completed the Hello/HelloAck discovery handshake. This implies that
+ * only message F4 may be replaced by a Commit. This constraint guarantees
+ * that both peers have seen at least one Hello.
+ *
+ * When entering this transition function:
+ * - The instance variabe sentPacket contains own Hello packet
+ * - The instance variabe commitPkt points to prepared Commit packet
+ * - Timer T1 is active
+ *
+ * Possible events in this state are:
+ * - timeout for sent Hello packet: causes a resend check and repeat sending
+ * of Hello packet
+ * - HelloAck: The peer answered with HelloAck to own HelloAck/Hello. Send
+ * prepared Commit packet and try Initiator mode.
+ * - Commit: The peer answered with Commit to HelloAck/Hello, thus switch to
+ * responder mode.
+ * - Hello: If the protcol engine receives another Hello it repeats the
+ * HelloAck/Hello response until Timer T1 exceeds its maximum. This may
+ * happen if the other peer sends Hello only (maybe due to network problems)
+ */
+void ZrtpStateClass::evAckSent(void) {
+
+ DEBUGOUT((cout << "Checking for match in AckSent.\n"));
+
+ char *msg, first, last;
+ uint8_t *pkt;
+ uint32_t errorCode = 0;
+
+ /*
+ * First check the general event type, then discrimnate
+ * the real event.
+ */
+ if (event->type == ZrtpPacket) {
+ pkt = event->packet;
+ msg = (char *)pkt + 4;
+
+ first = tolower(*msg);
+ last = tolower(*(msg+7));
+
+ /*
+ * HelloAck:
+ * The peer answers with HelloAck to own HelloAck/Hello. Send Commit
+ * and try Initiator mode. The requirement defined in chapter 4.1 to
+ * have a complete Hello/HelloAck is fulfilled.
+ * - stop Hello timer T1
+ * - send own Commit message
+ * - switch state to CommitSent, start Commit timer, assume Initiator
+ */
+ if (first == 'h' && last =='k') {
+ cancelTimer();
+
+ // remember packet for easy resend in case timer triggers
+ // Timer trigger received in new state CommitSend
+ sentPacket = static_cast<ZrtpPacketBase *>(commitPkt);
+ commitPkt = NULL; // now stored in sentPacket
+ nextState(CommitSent);
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ return;
+ }
+ if (startTimer(&T2) <= 0) {
+ timerFailed(SevereNoTimer); // returns to state Initial
+ }
+ return;
+ }
+ /*
+ * Hello:
+ * - peer didn't receive our HelloAck
+ * - repeat HelloAck/Hello response:
+ * -- get HelloAck packet, send it
+ * -- The timeout trigger of T1 sends our Hello packet
+ * -- stay in state AckSent
+ *
+ * Similar to Detect state: just acknowledge the Hello, the next
+ * timeout sends the following Hello.
+ */
+
+ if (first == 'h' && last ==' ') {
+ ZrtpPacketHelloAck* helloAck = parent->prepareHelloAck();
+
+ if (!parent->sendPacketZRTP(static_cast<ZrtpPacketBase *>(helloAck))) {
+ nextState(Detect);
+ parent->zrtpNegotiationFailed(Severe, SevereCannotSend);
+ }
+ return;
+ }
+ /*
+ * Commit:
+ * The peer answers with Commit to HelloAck/Hello, thus switch to
+ * responder mode.
+ * - stop timer T1
+ * - prepare and send our DHPart1
+ * - switch to state WaitDHPart2 and wait for peer's DHPart2
+ * - don't start timer, we are responder
+ */
+ if (first == 'c') {
+ cancelTimer();
+ ZrtpPacketCommit cpkt(pkt);
+
+ if (!multiStream) {
+ ZrtpPacketDHPart* dhPart1 = parent->prepareDHPart1(&cpkt, &errorCode);
+
+ // Something went wrong during processing of the Commit packet
+ if (dhPart1 == NULL) {
+ if (errorCode != IgnorePacket) {
+ sendErrorPacket(errorCode);
+ }
+ return;
+ }
+ commitPkt = NULL;
+ sentPacket = static_cast<ZrtpPacketBase *>(dhPart1);
+ nextState(WaitDHPart2);
+ }
+ else {
+ ZrtpPacketConfirm* confirm = parent->prepareConfirm1MultiStream(&cpkt, &errorCode);
+
+ // Something went wrong during processing of the Commit packet
+ if (confirm == NULL) {
+ if (errorCode != IgnorePacket) {
+ sendErrorPacket(errorCode);
+ }
+ return;
+ }
+ sentPacket = static_cast<ZrtpPacketBase *>(confirm);
+ nextState(WaitConfirm2);
+ }
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ }
+ }
+ }
+ /*
+ * Timer:
+ * - resend Hello packet, stay in state, restart timer until repeat
+ * counter triggers
+ * - if repeat counter triggers switch to state Detect, con't clear
+ * sentPacket, Detect requires it to point to own Hello message
+ */
+ else if (event->type == Timer) {
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ return sendFailed(); // returns to state Initial
+ }
+ if (nextTimer(&T1) <= 0) {
+ parent->zrtpNotSuppOther();
+ commitPkt = NULL;
+ // Stay in state Detect to be prepared get an hello from
+ // other peer any time later
+ nextState(Detect);
+ }
+ }
+ else { // unknown Event type for this state (covers Error and ZrtpClose)
+ if (event->type != ZrtpClose) {
+ parent->zrtpNegotiationFailed(Severe, SevereProtocolError);
+ }
+ commitPkt = NULL;
+ sentPacket = NULL;
+ nextState(Initial);
+ }
+}
+/*
+ * AckDetected state.
+ *
+ * The protocol engine received a HelloAck in state Detect, thus the peer
+ * acknowledged our the Hello. According to ZRT RFC xxxx our peer must send
+ * its Hello until our protocol engine sees it (refer also to comment for
+ * state AckSent). This protocol sequence gurantees that both peers got at
+ * least one Hello.
+ *
+ * When entering this transition function
+ * - instance variable sentPacket is NULL, Hello timer stopped
+ *
+ * Possible events in this state are:
+ * Hello: we have to choices
+ * 1) we can acknowledge the peer's Hello with a HelloAck
+ * 2) we can acknowledge the peer's Hello with a Commit
+ * Both choices are implemented and may be enabled by setting a compile
+ * time #if (see code below). Currently we use choice 1) here because
+ * it's more aligned to the ZRTP specification
+ */
+void ZrtpStateClass::evAckDetected(void) {
+
+ DEBUGOUT((cout << "Checking for match in AckDetected.\n"));
+
+ char *msg, first, last;
+ uint8_t *pkt;
+ uint32_t errorCode = 0;
+
+ if (event->type == ZrtpPacket) {
+ pkt = event->packet;
+ msg = (char *)pkt + 4;
+
+ first = tolower(*msg);
+ last = tolower(*(msg+7));
+
+#if 1
+ /*
+ * Implementation for choice 1)
+ * Hello:
+ * - Acknowledge peers Hello, sending HelloACK (F4)
+ * - switch to state WaitCommit, wait for peer's Commit
+ * - we are going to be in the Responder role
+ */
+
+ if (first == 'h' && last ==' ') {
+ // Parse Hello packet and build an own Commit packet even if the
+ // Commit is not send to the peer. We need to do this to check the
+ // Hello packet and prepare the shared secret stuff.
+ ZrtpPacketHello hpkt(pkt);
+ ZrtpPacketCommit* commit = parent->prepareCommit(&hpkt, &errorCode);
+
+ // Something went wrong during processing of the Hello packet, for
+ // example wrong version, duplicate ZID.
+ if (commit == NULL) {
+ sendErrorPacket(errorCode);
+ return;
+ }
+ ZrtpPacketHelloAck *helloAck = parent->prepareHelloAck();
+ nextState(WaitCommit);
+
+ // remember packet for easy resend
+ sentPacket = static_cast<ZrtpPacketBase *>(helloAck);
+ if (!parent->sendPacketZRTP(static_cast<ZrtpPacketBase *>(helloAck))) {
+ sendFailed();
+ }
+ }
+#else
+ /*
+ * Implementation for choice 2)
+ * Hello:
+ * - Acknowledge peers Hello by sending Commit (F5)
+ * instead of HelloAck (F4)
+ * - switch to state CommitSent
+ * - Initiator role, thus start timer T2 to monitor timeout for Commit
+ */
+
+ if (first == 'h') {
+ // Parse peer's packet data into a Hello packet
+ ZrtpPacketHello hpkt(pkt);
+ ZrtpPacketCommit* commit = parent->prepareCommit(&hpkt, &errorCode);
+ // Something went wrong during processing of the Hello packet
+ if (commit == NULL) {
+ sendErrorPacket(errorCode);
+ return;
+ }
+ nextState(CommitSent);
+
+ // remember packet for easy resend in case timer triggers
+ // Timer trigger received in new state CommitSend
+ sentPacket = static_cast<ZrtpPacketBase *>(commit);
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed();
+ return;
+ }
+ if (startTimer(&T2) <= 0) {
+ timerFailed(SevereNoTimer);
+ }
+ }
+#endif
+ }
+ else { // unknown Event type for this state (covers Error and ZrtpClose)
+ if (event->type != ZrtpClose) {
+ parent->zrtpNegotiationFailed(Severe, SevereProtocolError);
+ }
+ nextState(Initial);
+ }
+}
+
+/*
+ * WaitCommit state.
+ *
+ * This state is only used if we use choice 1) in AckDetected.
+ *
+ * When entering this transition function
+ * - instance variable sentPacket contains a HelloAck packet
+ *
+ * Possible events in this state are:
+ * - Hello: just resend our HelloAck
+ * - Commit: prepare and send our DHPart1 message to start first
+ * half of DH key agreement. Switch to state WaitDHPart2, don't
+ * start any timer, we a Responder.
+ */
+void ZrtpStateClass::evWaitCommit(void) {
+
+ DEBUGOUT((cout << "Checking for match in WaitCommit.\n"));
+
+ char *msg, first;
+ uint8_t *pkt;
+ uint32_t errorCode = 0;
+
+ if (event->type == ZrtpPacket) {
+ pkt = event->packet;
+ msg = (char *)pkt + 4;
+
+ first = tolower(*msg);
+ /*
+ * Hello:
+ * - resend HelloAck
+ * - stay in WaitCommit
+ */
+ if (first == 'h') {
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ }
+ return;
+ }
+ /*
+ * Commit:
+ * - prepare DH1Part packet or Confirm1 if multi stream mode
+ * - send it to peer
+ * - switch state to WaitDHPart2 or WaitConfirm2 if multi stream mode
+ * - don't start timer, we are responder
+ */
+ if (first == 'c') {
+ ZrtpPacketCommit cpkt(pkt);
+
+ if (!multiStream) {
+ ZrtpPacketDHPart* dhPart1 = parent->prepareDHPart1(&cpkt, &errorCode);
+
+ // Something went wrong during processing of the Commit packet
+ if (dhPart1 == NULL) {
+ if (errorCode != IgnorePacket) {
+ sendErrorPacket(errorCode);
+ }
+ return;
+ }
+ sentPacket = static_cast<ZrtpPacketBase *>(dhPart1);
+ nextState(WaitDHPart2);
+ }
+ else {
+ ZrtpPacketConfirm* confirm = parent->prepareConfirm1MultiStream(&cpkt, &errorCode);
+
+ // Something went wrong during processing of the Commit packet
+ if (confirm == NULL) {
+ if (errorCode != IgnorePacket) {
+ sendErrorPacket(errorCode);
+ }
+ return;
+ }
+ sentPacket = static_cast<ZrtpPacketBase *>(confirm);
+ nextState(WaitConfirm2);
+ }
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ }
+ }
+ }
+ else { // unknown Event type for this state (covers Error and ZrtpClose)
+ if (event->type != ZrtpClose) {
+ parent->zrtpNegotiationFailed(Severe, SevereProtocolError);
+ }
+ sentPacket = NULL;
+ nextState(Initial);
+ }
+}
+
+/*
+ * CommitSent state.
+ *
+ * This state either handles a DH1Part1 message to start the first
+ * half of DH key agreement or it handles a Commit clash. If handling a
+ * Commit clash it may happen that we change our role from Initiator to
+ * Responder.
+ *
+ * When entering this transition function
+ * - assume Initiator mode, may change if we reveice a Commit here
+ * - sentPacket contains Commit packet
+ * - Commit timer (T2) active
+ *
+ * Possible events in this state are:
+ * - timeout for sent Commit packet: causes a resend check and repeat sending
+ * of Commit packet
+ * - Commit: This is a Commit clash. Break the tie accroding to chapter 5.2
+ * - DHPart1: start first half of DH key agreement. Perpare and send own DHPart2
+ * and switch to state WaitConfirm1.
+ */
+
+void ZrtpStateClass::evCommitSent(void) {
+
+ DEBUGOUT((cout << "Checking for match in CommitSend.\n"));
+
+ char *msg, first, last;
+ uint8_t *pkt;
+ uint32_t errorCode = 0;
+
+ if (event->type == ZrtpPacket) {
+ pkt = event->packet;
+ msg = (char *)pkt + 4;
+
+ first = tolower(*msg);
+ last = tolower(*(msg+7));
+
+ /*
+ * HelloAck or Hello:
+ * - delayed "HelloAck" or "Hello", maybe due to network latency, just
+ * ignore it
+ * - no switch in state, leave timer as it is
+ */
+ if (first == 'h' && (last =='k' || last == ' ')) {
+ return;
+ }
+
+ /*
+ * Commit:
+ * We have a "Commit" clash. Resolve it.
+ *
+ * - switch off resending Commit
+ * - compare my hvi with peer's hvi
+ * - if my hvi is greater
+ * - we are Initiator, stay in state, wait for peer's DHPart1 packet
+ * - else
+ * - we are Responder, stop timer
+ * - prepare and send DH1Packt,
+ * - switch to state WaitDHPart2, implies Responder path
+ */
+ if (first == 'c' && last == ' ') {
+ ZrtpPacketCommit zpCo(pkt);
+
+ if (!parent->verifyH2(&zpCo)) {
+ return;
+ }
+ cancelTimer(); // this cancels the Commit timer T2
+
+ // if our hvi is less than peer's hvi: switch to Responder mode and
+ // send DHPart1 or Confirm1 packet. Peer (as Initiator) will retrigger if
+ // necessary
+ //
+ if (parent->compareCommit(&zpCo) < 0) {
+ if (!multiStream) {
+ ZrtpPacketDHPart* dhPart1 = parent->prepareDHPart1(&zpCo, &errorCode);
+
+ // Something went wrong during processing of the Commit packet
+ if (dhPart1 == NULL) {
+ if (errorCode != IgnorePacket) {
+ sendErrorPacket(errorCode);
+ }
+ return;
+ }
+ nextState(WaitDHPart2);
+ sentPacket = static_cast<ZrtpPacketBase *>(dhPart1);
+ }
+ else {
+ ZrtpPacketConfirm* confirm = parent->prepareConfirm1MultiStream(&zpCo, &errorCode);
+
+ // Something went wrong during processing of the Commit packet
+ if (confirm == NULL) {
+ if (errorCode != IgnorePacket) {
+ sendErrorPacket(errorCode);
+ }
+ return;
+ }
+ nextState(WaitConfirm2);
+ sentPacket = static_cast<ZrtpPacketBase *>(confirm);
+ }
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ }
+ }
+ // Stay in state, we are Initiator, wait for DHPart1 of Confirm1 packet from peer.
+ // Resend Commit after timeout until we get a DHPart1 or Confirm1
+ else {
+ if (startTimer(&T2) <= 0) { // restart the Commit timer, gives peer more time to react
+ timerFailed(SevereNoTimer); // returns to state Initial
+ }
+ }
+ return;
+ }
+
+ /*
+ * DHPart1:
+ * - switch off resending Commit
+ * - Prepare and send DHPart2
+ * - switch to WaitConfirm1
+ * - start timer to resend DHPart2 if necessary, we are Initiator
+ */
+ if (first == 'd') {
+ cancelTimer();
+ sentPacket = NULL;
+ ZrtpPacketDHPart dpkt(pkt);
+ ZrtpPacketDHPart* dhPart2 = parent->prepareDHPart2(&dpkt, &errorCode);
+
+ // Something went wrong during processing of the DHPart1 packet
+ if (dhPart2 == NULL) {
+ if (errorCode != IgnorePacket) {
+ sendErrorPacket(errorCode);
+ }
+ else {
+ if (startTimer(&T2) <= 0) {
+ timerFailed(SevereNoTimer); // switches to state Initial
+ }
+ }
+
+ return;
+ }
+ sentPacket = static_cast<ZrtpPacketBase *>(dhPart2);
+ nextState(WaitConfirm1);
+
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ return;
+ }
+ if (startTimer(&T2) <= 0) {
+ timerFailed(SevereNoTimer); // switches to state Initial
+ }
+ return;
+ }
+
+ if (multiStream && (first == 'c' && last == '1')) {
+ cancelTimer();
+ ZrtpPacketConfirm cpkt(pkt);
+
+ ZrtpPacketConfirm* confirm = parent->prepareConfirm2MultiStream(&cpkt, &errorCode);
+
+ // Something went wrong during processing of the Confirm1 packet
+ if (confirm == NULL) {
+ sendErrorPacket(errorCode);
+ return;
+ }
+ nextState(WaitConfAck);
+ sentPacket = static_cast<ZrtpPacketBase *>(confirm);
+
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ return;
+ }
+ if (startTimer(&T2) <= 0) {
+ timerFailed(SevereNoTimer); // returns to state Initial
+ return;
+ }
+ // according to chap 5.6: after sending Confirm2 the Initiator must
+ // be ready to receive SRTP data. SRTP sender will be enabled in WaitConfAck
+ // state.
+ if (!parent->srtpSecretsReady(ForReceiver)) {
+ parent->sendInfo(Severe, CriticalSWError);
+ sendErrorPacket(CriticalSWError);
+ return;
+ }
+ }
+ }
+ // Timer event triggered, resend the Commit packet
+ else if (event->type == Timer) {
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ return;
+ }
+ if (nextTimer(&T2) <= 0) {
+ timerFailed(SevereTooMuchRetries); // returns to state Initial
+ }
+ }
+ else { // unknown Event type for this state (covers Error and ZrtpClose)
+ if (event->type != ZrtpClose) {
+ parent->zrtpNegotiationFailed(Severe, SevereProtocolError);
+ }
+ sentPacket = NULL;
+ nextState(Initial);
+ }
+}
+
+/*
+ * WaitDHPart2 state.
+ *
+ * This state handles the second part of SH key agreement. Only the Resonder
+ * can enter this state.
+ *
+ * When entering this transition function
+ * - sentPacket contains DHPart1 packet, no timer active
+ *
+ * Possible events in this state are:
+ * - Commit: Our peer didn't receive out DHPart1 thus the peer sends Commit again.
+ * Just repeat our DHPart1.
+ * - DHPart2: start second half of DH key agreement. Perpare and send own Confirm1
+ * and switch to state WaitConfirm2.
+ */
+void ZrtpStateClass::evWaitDHPart2(void) {
+
+ DEBUGOUT((cout << "Checking for match in DHPart2.\n"));
+
+ char *msg, first;
+ uint8_t *pkt;
+ uint32_t errorCode = 0;
+
+ if (event->type == ZrtpPacket) {
+ pkt = event->packet;
+ msg = (char *)pkt + 4;
+
+ first = tolower(*msg);
+ /*
+ * Commit:
+ * - resend DHPart1
+ * - stay in state
+ */
+ if (first == 'c') {
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ return sendFailed(); // returns to state Initial
+ }
+ return;
+ }
+ /*
+ * DHPart2:
+ * - prepare Confirm1 packet
+ * - switch to WaitConfirm2
+ * - No timer, we are responder
+ */
+ if (first == 'd') {
+ ZrtpPacketDHPart dpkt(pkt);
+ ZrtpPacketConfirm* confirm = parent->prepareConfirm1(&dpkt, &errorCode);
+
+ if (confirm == NULL) {
+ if (errorCode != IgnorePacket) {
+ sendErrorPacket(errorCode);
+ }
+ return;
+ }
+ nextState(WaitConfirm2);
+ sentPacket = static_cast<ZrtpPacketBase *>(confirm);
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ }
+ }
+ }
+ else { // unknown Event type for this state (covers Error and ZrtpClose)
+ if (event->type != ZrtpClose) {
+ parent->zrtpNegotiationFailed(Severe, SevereProtocolError);
+ }
+ sentPacket = NULL;
+ nextState(Initial);
+ }
+}
+
+/*
+ * WaitConirm1 state.
+ *
+ * This state handles a received Confirm1 message and only the Initiator
+ * can enter this state.
+ *
+ * When entering this transition function in DH mode:
+ * - Initiator mode
+ * - sentPacket contains DHPart2 packet, DHPart2 timer active
+ *
+ * When entering this transition function in Multi stream mode via AckSent:
+ * - Initiator mode
+ * - sentPacket contains my Commit packet, Commit timer active
+ *
+* Possible events in this state are:
+ * - timeout for sent DHPart2 packet: causes a resend check and repeat sending
+ * of DHPart2 packet.
+ * - Confirm1: Check Confirm1 message. If it is ok then prepare and send own
+ * Confirm2 packet and switch to state WaitConfAck.
+ */
+void ZrtpStateClass::evWaitConfirm1(void) {
+
+ DEBUGOUT((cout << "Checking for match in WaitConfirm1.\n"));
+
+ char *msg, first, last;
+ uint8_t *pkt;
+ uint32_t errorCode = 0;
+
+ if (event->type == ZrtpPacket) {
+ pkt = event->packet;
+ msg = (char *)pkt + 4;
+
+ first = tolower(*msg);
+ last = tolower(*(msg+7));
+
+ /*
+ * Confirm1:
+ * - Switch off resending DHPart2
+ * - prepare a Confirm2 packet
+ * - switch to state WaitConfAck
+ * - set timer to monitor Confirm2 packet, we are initiator
+ */
+ if (first == 'c' && last == '1') {
+ cancelTimer();
+ ZrtpPacketConfirm cpkt(pkt);
+
+ ZrtpPacketConfirm* confirm = parent->prepareConfirm2(&cpkt, &errorCode);
+
+ // Something went wrong during processing of the Confirm1 packet
+ if (confirm == NULL) {
+ sendErrorPacket(errorCode);
+ return;
+ }
+ nextState(WaitConfAck);
+ sentPacket = static_cast<ZrtpPacketBase *>(confirm);
+
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ return;
+ }
+ if (startTimer(&T2) <= 0) {
+ timerFailed(SevereNoTimer); // returns to state Initial TODO check for return following this line
+ }
+ // according to chap 5.8: after sending Confirm2 the Initiator must
+ // be ready to receive SRTP data. SRTP sender will be enabled in WaitConfAck
+ // state.
+ if (!parent->srtpSecretsReady(ForReceiver)) {
+ parent->sendInfo(Severe, CriticalSWError);
+ sendErrorPacket(CriticalSWError);
+ return;
+ }
+ }
+ }
+ else if (event->type == Timer) {
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ return;
+ }
+ if (nextTimer(&T2) <= 0) {
+ timerFailed(SevereTooMuchRetries); // returns to state Initial
+ }
+ }
+ else { // unknown Event type for this state (covers Error and ZrtpClose)
+ if (event->type != ZrtpClose) {
+ parent->zrtpNegotiationFailed(Severe, SevereProtocolError);
+ }
+ sentPacket = NULL;
+ nextState(Initial);
+ }
+}
+
+/*
+ * WaitConfirm2 state.
+ *
+ * Handles the Confirm2 message that closes the key agreement handshake. Only
+ * the Responder can enter this state. If the Confirm2 message is ok send a
+ * Conf2Ack to our peer. Switch to secure mode after sending Conf2Ack, our
+ * peer switches to secure mode after receiving Conf2Ack.
+ *
+ * TODO - revise documentation comments
+ *
+ * When entering this transition function
+ * - Responder mode
+ * - sentPacket contains Confirm1 packet, no timer active
+ *
+ * Possible events in this state are:
+ * - DHPart2: Our peer didn't receive our Confirm1 thus sends DHPart2 again.
+ * Just repeat our Confirm1.
+ * - Confirm2: close DH key agreement. Perpare and send own Conf2Ack
+ * and switch to state SecureState.
+ */
+void ZrtpStateClass::evWaitConfirm2(void) {
+
+ DEBUGOUT((cout << "Checking for match in WaitConfirm2.\n"));
+
+ char *msg, first, last;
+ uint8_t *pkt;
+ uint32_t errorCode = 0;
+
+ if (event->type == ZrtpPacket) {
+ pkt = event->packet;
+ msg = (char *)pkt + 4;
+
+ first = tolower(*msg);
+ last = tolower(*(msg+7));
+
+ /*
+ * DHPart2 or Commit in multi stream mode:
+ * - resend Confirm1 packet
+ * - stay in state
+ */
+ if (first == 'd' || (multiStream && (first == 'c' && last == ' '))) {
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ }
+ return;
+ }
+ /*
+ * Confirm2:
+ * - prepare ConfAck
+ * - switch on security (SRTP)
+ * - switch to SecureState
+ */
+ if (first == 'c' && last == '2') {
+ ZrtpPacketConfirm cpkt(pkt);
+ ZrtpPacketConf2Ack* confack = parent->prepareConf2Ack(&cpkt, &errorCode);
+
+ // Something went wrong during processing of the confirm2 packet
+ if (confack == NULL) {
+ sendErrorPacket(errorCode);
+ return;
+ }
+ sentPacket = static_cast<ZrtpPacketBase *>(confack);
+
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ return;
+ }
+ if (!parent->srtpSecretsReady(ForSender) ||
+ !parent->srtpSecretsReady(ForReceiver)) {
+ parent->sendInfo(Severe, CriticalSWError);
+ sendErrorPacket(CriticalSWError);
+ return;
+ }
+ nextState(SecureState);
+ parent->sendInfo(Info, InfoSecureStateOn);
+ }
+ }
+ else { // unknown Event type for this state (covers Error and ZrtpClose)
+ if (event->type != ZrtpClose) {
+ parent->zrtpNegotiationFailed(Severe, SevereProtocolError);
+ }
+ sentPacket = NULL;
+ nextState(Initial);
+ }
+}
+
+/*
+ * WaitConf2Ack state.
+ *
+ * This state handles the Conf2Ack message that acknowledges the successfull
+ * processing of Confirm2. Only the Initiator can enter this state. Switch on
+ * secure mode and switch to state SecureState.
+ *
+ * When entering this transition function
+ * - Initiator mode
+ * - sentPacket contains Confirm2 packet, Confirm2 timer active
+ * - receiver security switched on
+ *
+ * Possible events in this state are:
+ * - timeout for sent Confirm2 packet: causes a resend check and repeat sending
+ * of Confirm2 packet
+ * - Conf2Ack: Key agreement was successfull, switch to secure mode.
+ */
+void ZrtpStateClass::evWaitConfAck(void) {
+
+ DEBUGOUT((cout << "Checking for match in WaitConfAck.\n"));
+
+ char *msg, first;
+ uint8_t *pkt;
+
+ if (event->type == ZrtpPacket) {
+ pkt = event->packet;
+ msg = (char *)pkt + 4;
+
+ first = tolower(*msg);
+ /*
+ * ConfAck:
+ * - Switch off resending Confirm2
+ * - switch to SecureState
+ */
+ if (first == 'c') {
+ cancelTimer();
+ sentPacket = NULL;
+ // Receiver was already enabled after sending Confirm2 packet
+ // see previous states.
+ if (!parent->srtpSecretsReady(ForSender)) {
+ parent->sendInfo(Severe, CriticalSWError);
+ sendErrorPacket(CriticalSWError);
+ return;
+ }
+ nextState(SecureState);
+ // TODO: call parent to clear signature data at initiator
+ parent->sendInfo(Info, InfoSecureStateOn);
+ }
+ }
+ else if (event->type == Timer) {
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ parent->srtpSecretsOff(ForReceiver);
+ return;
+ }
+ if (nextTimer(&T2) <= 0) {
+ timerFailed(SevereTooMuchRetries); // returns to state Initial
+ parent->srtpSecretsOff(ForReceiver);
+ }
+ }
+ else { // unknown Event type for this state (covers Error and ZrtpClose)
+ if (event->type != ZrtpClose) {
+ parent->zrtpNegotiationFailed(Severe, SevereProtocolError);
+ }
+ sentPacket = NULL;
+ nextState(Initial);
+ parent->srtpSecretsOff(ForReceiver);
+ }
+}
+
+/*
+ * When entering this transition function
+ * - sentPacket contains GoClear packet, GoClear timer active
+ */
+
+void ZrtpStateClass::evWaitClearAck(void) {
+ DEBUGOUT((cout << "Checking for match in ClearAck.\n"));
+
+ char *msg, first, last;
+ uint8_t *pkt;
+
+ if (event->type == ZrtpPacket) {
+ pkt = event->packet;
+ msg = (char *)pkt + 4;
+
+ first = tolower(*msg);
+ last = tolower(*(msg+7));
+
+ /*
+ * ClearAck:
+ * - stop resending GoClear,
+ * - switch to state AckDetected, wait for peer's Hello
+ */
+ if (first == 'c' && last =='k') {
+ cancelTimer();
+ sentPacket = NULL;
+ nextState(Initial);
+ }
+ }
+ // Timer event triggered - this is Timer T2 to resend GoClear w/o HMAC
+ else if (event->type == Timer) {
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ return;
+ }
+ if (nextTimer(&T2) <= 0) {
+ timerFailed(SevereTooMuchRetries); // returns to state Initial
+ }
+ }
+ else { // unknown Event type for this state (covers Error and ZrtpClose)
+ if (event->type != ZrtpClose) {
+ parent->zrtpNegotiationFailed(Severe, SevereProtocolError);
+ }
+ sentPacket = NULL;
+ nextState(Initial);
+ }
+}
+
+
+/*
+ * WaitErrorAck state.
+ *
+ * This state belongs to the "error handling state overlay" and handle
+ * ErrorAck message. Most of the ZRTP states can send Error message for
+ * example if they detect wrong packets. After sending an Error message
+ * the protocol engine switches to WaitErrorAck state. Receiving an
+ * ErrorAck message completes the ZRTP error handling.
+ *
+ * When entering this transition function
+ * - sentPacket contains Error packet, Error timer active
+ *
+ * Possible events in this state are:
+ * - timeout for sent Error packet: causes a resend check and repeat sending
+ * of Error packet
+ * - ErrorAck: Stop timer and switch to state Initial.
+ */
+
+void ZrtpStateClass::evWaitErrorAck(void) {
+ DEBUGOUT((cout << "Checking for match in ErrorAck.\n"));
+
+ char *msg, first, last;
+ uint8_t *pkt;
+
+ if (event->type == ZrtpPacket) {
+ pkt = event->packet;
+ msg = (char *)pkt + 4;
+
+ first = tolower(*msg);
+ last = tolower(*(msg+7));
+
+ /*
+ * Errorck:
+ * - stop resending Error,
+ * - switch to state Initial
+ */
+ if (first == 'e' && last =='k') {
+ cancelTimer();
+ sentPacket = NULL;
+ nextState(Initial);
+ }
+ }
+ // Timer event triggered - this is Timer T2 to resend Error.
+ else if (event->type == Timer) {
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ return;
+ }
+ if (nextTimer(&T2) <= 0) {
+ timerFailed(SevereTooMuchRetries); // returns to state Initial
+ }
+ }
+ else { // unknown Event type for this state (covers Error and ZrtpClose)
+ if (event->type != ZrtpClose) {
+ parent->zrtpNegotiationFailed(Severe, SevereProtocolError);
+ }
+ sentPacket = NULL;
+ nextState(Initial);
+ }
+}
+
+void ZrtpStateClass::evSecureState(void) {
+
+ DEBUGOUT((cout << "Checking for match in SecureState.\n"));
+
+ char *msg, first, last;
+ uint8_t *pkt;
+
+ /*
+ * Handle a possible substate. If substate handling was ok just return.
+ */
+ if (secSubstate == WaitSasRelayAck) {
+ if (subEvWaitRelayAck())
+ return;
+ }
+
+ if (event->type == ZrtpPacket) {
+ pkt = event->packet;
+ msg = (char *)pkt + 4;
+
+ first = tolower(*msg);
+ last = tolower(*(msg+7));
+
+ /*
+ * Confirm2:
+ * - resend Conf2Ack packet
+ * - stay in state
+ */
+ if (first == 'c' && last == '2') {
+ if (sentPacket != NULL && !parent->sendPacketZRTP(sentPacket)) {
+ sentPacket = NULL;
+ nextState(Initial);
+ parent->srtpSecretsOff(ForSender);
+ parent->srtpSecretsOff(ForReceiver);
+ parent->zrtpNegotiationFailed(Severe, SevereCannotSend);
+ }
+ return;
+ }
+ /*
+ * GoClear received, handle it. TODO fix go clear handling
+ */
+ if (first == 'g' && last == 'r') {
+ ZrtpPacketGoClear gpkt(pkt);
+ ZrtpPacketClearAck* clearAck = parent->prepareClearAck(&gpkt);
+
+ if (!parent->sendPacketZRTP(static_cast<ZrtpPacketBase *>(clearAck))) {
+ return;
+ }
+ // TODO Timeout to resend clear ack until user user confirmation
+ }
+ }
+ else { // unknown Event type for this state (covers Error and ZrtpClose)
+ sentPacket = NULL;
+ parent->srtpSecretsOff(ForSender);
+ parent->srtpSecretsOff(ForReceiver);
+ nextState(Initial);
+ if (event->type != ZrtpClose) {
+ parent->zrtpNegotiationFailed(Severe, SevereProtocolError);
+ }
+ parent->sendInfo(Info, InfoSecureStateOff);
+ }
+}
+
+bool ZrtpStateClass::subEvWaitRelayAck() {
+ char *msg, first, last;
+ uint8_t* pkt;
+
+ /*
+ * First check the general event type, then discrimnate the real event.
+ */
+ if (event->type == ZrtpPacket) {
+ pkt = event->packet;
+ msg = (char *)pkt + 4;
+
+ first = tolower(*msg);
+ last = tolower(*(msg+7));
+
+ /*
+ * SAS relayAck:
+ * - stop resending SASRelay,
+ * - switch to secure substate Normal
+ */
+ if (first == 'r' && last =='k') {
+ cancelTimer();
+ secSubstate = Normal;
+ sentPacket = NULL;
+ }
+ return true;
+ }
+ // Timer event triggered - this is Timer T2 to resend Error.
+ else if (event->type == Timer) {
+ if (!parent->sendPacketZRTP(sentPacket)) {
+ sendFailed(); // returns to state Initial
+ return false;
+ }
+ if (nextTimer(&T2) <= 0) {
+ // returns to state initial
+ // timerFailed(ZrtpCodes.SevereCodes.SevereTooMuchRetries);
+ return false;
+ }
+ return true;
+ }
+ return false;
+}
+
+int32_t ZrtpStateClass::startTimer(zrtpTimer_t *t) {
+
+ t->time = t->start;
+ t->counter = 0;
+ return parent->activateTimer(t->time);
+}
+
+int32_t ZrtpStateClass::nextTimer(zrtpTimer_t *t) {
+
+ t->time += t->time;
+ t->time = (t->time > t->capping)? t->capping : t->time;
+ t->counter++;
+ if (t->counter > t->maxResend) {
+ return -1;
+ }
+ return parent->activateTimer(t->time);
+}
+
+void ZrtpStateClass::sendErrorPacket(uint32_t errorCode) {
+ cancelTimer();
+
+ ZrtpPacketError* err = parent->prepareError(errorCode);
+ parent->zrtpNegotiationFailed(ZrtpError, errorCode);
+
+ sentPacket = static_cast<ZrtpPacketBase *>(err);
+ nextState(WaitErrorAck);
+ if (!parent->sendPacketZRTP(static_cast<ZrtpPacketBase *>(err)) || (startTimer(&T2) <= 0)) {
+ sendFailed();
+ }
+}
+
+void ZrtpStateClass::sendSASRelay(ZrtpPacketSASrelay* relay) {
+ cancelTimer();
+ sentPacket = static_cast<ZrtpPacketBase *>(relay);
+ secSubstate = WaitSasRelayAck;
+ if (!parent->sendPacketZRTP(static_cast<ZrtpPacketBase *>(relay)) || (startTimer(&T2) <= 0)) {
+ sendFailed();
+ }
+}
+
+void ZrtpStateClass::sendFailed() {
+ sentPacket = NULL;
+ nextState(Initial);
+ parent->zrtpNegotiationFailed(Severe, SevereCannotSend);
+}
+
+void ZrtpStateClass::timerFailed(int32_t subCode) {
+ sentPacket = NULL;
+ nextState(Initial);
+ parent->zrtpNegotiationFailed(Severe, subCode);
+}
+
+void ZrtpStateClass::setMultiStream(bool multi) {
+ multiStream = multi;
+}
+
+bool ZrtpStateClass::isMultiStream() {
+ return multiStream;
+}
+
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-default-style: ellemtel
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/src/ZrtpTextData.cpp b/src/ZrtpTextData.cpp
new file mode 100644
index 0000000..5861099
--- /dev/null
+++ b/src/ZrtpTextData.cpp
@@ -0,0 +1,97 @@
+/*
+ Copyright (C) 2006-2008 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+#include <stdint.h>
+#include <libzrtpcpp/ZrtpConfigure.h>
+// 1
+// 1234567890123456
+char clientId[] = "GNU ZRTP 2.1.0 "; // 16 chars max.
+char zrtpVersion[] = "1.10"; // must be 4 chars
+/**
+ *
+ */
+char HelloMsg[] = "Hello ";
+char HelloAckMsg[] = "HelloACK";
+char CommitMsg[] = "Commit ";
+char DHPart1Msg[] = "DHPart1 ";
+char DHPart2Msg[] = "DHPart2 ";
+char Confirm1Msg[] = "Confirm1";
+char Confirm2Msg[] = "Confirm2";
+char Conf2AckMsg[] = "Conf2ACK";
+char ErrorMsg[] = "Error ";
+char ErrorAckMsg[] = "ErrorACK";
+char GoClearMsg[] = "GoClear ";
+char ClearAckMsg[] = "ClearACK";
+char PingMsg[] = "Ping ";
+char PingAckMsg[] = "PingACK ";
+char SasRelayMsg[] = "SASrelay";
+char RelayAckMsg[] = "RelayACK";
+
+char responder[] = "Responder";
+char initiator[] = "Initiator";
+char iniMasterKey[] = "Initiator SRTP master key";
+char iniMasterSalt[] = "Initiator SRTP master salt";
+char respMasterKey[] = "Responder SRTP master key";
+char respMasterSalt[] = "Responder SRTP master salt";
+
+char iniHmacKey[] = "Initiator HMAC key";
+char respHmacKey[] = "Responder HMAC key";
+char retainedSec[] = "retained secret";
+
+char iniZrtpKey[] = "Initiator ZRTP key";
+char respZrtpKey[] = "Responder ZRTP key";
+
+char sasString[] = "SAS";
+
+char KDFString[] = "ZRTP-HMAC-KDF";
+
+char zrtpSessionKey[] = "ZRTP Session Key";
+
+char zrtpMsk[] = "ZRTP MSK";
+char zrtpTrustedMitm[] = "Trusted MiTM key";
+
+char s256[] = "S256";
+char s384[] = "S384";
+const char* mandatoryHash = s256;
+
+char aes3[] = "AES3";
+char aes2[] = "AES2";
+char aes1[] = "AES1";
+char two3[] = "2FS3";
+char two2[] = "2FS2";
+char two1[] = "2FS1";
+const char* mandatoryCipher = aes1;
+
+char dh2k[] = "DH2k";
+char ec25[] = "EC25";
+char dh3k[] = "DH3k";
+char ec38[] = "EC38";
+char mult[] = "Mult";
+const char* mandatoryPubKey = dh3k;
+
+char b32[] = "B32 ";
+const char* mandatorySasType = b32;
+
+char hs32[] = "HS32";
+char hs80[] = "HS80";
+char sk32[] = "SK32";
+char sk64[] = "SK64";
+const char* mandatoryAuthLen_1 = hs32;
+const char* mandatoryAuthLen_2 = hs80;
diff --git a/src/libzrtpcpp/Base32.h b/src/libzrtpcpp/Base32.h
new file mode 100644
index 0000000..fbe2983
--- /dev/null
+++ b/src/libzrtpcpp/Base32.h
@@ -0,0 +1,228 @@
+#ifndef BASE32_H
+#define BASE32_H
+
+/*
+ *
+ * Copyright (c) 2002 Bryce "Zooko" Wilcox-O'Hearn Permission is hereby
+ * granted, free of charge, to any person obtaining a copy of this software to
+ * deal in this software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of this software, and to permit persons to whom this software
+ * is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of this software.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THIS SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THIS SOFTWARE.
+ *
+ * Converted to C++ by:
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+/**
+ * @file Base32.h
+ * @brief C++ implmentation of the Base32 encoding and decoding
+ *
+ * ZRTP uses the base 32 encoding and decoding to generate the Short
+ * Authentication String (SAS).
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <iostream>
+#include <cstdlib>
+
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>
+
+using namespace std;
+
+extern int divceil(int a, int b);
+
+class Base32 {
+
+ public:
+
+ /**
+ * A Constructor that decodes from base32 into binary.
+ *
+ * The constructor decodes the base32 encoded data back into binary
+ * data. Use <code>getDecoded(...)</code> to get the binary data.
+ *
+ * @param encoded
+ * The string that contains the base32 encoded data.
+ */
+ Base32(const string encoded);
+
+ /**
+ * A Constructor that decodes from base32 into binary.
+ *
+ * This constructor decodes the base32 encoded data back into
+ * binary data. Only the specified number of bits are decoded
+ * (should be a multiple of 5). Use
+ * <code>getDecoded(...)</code> to get the binary data.
+ *
+ * @param encoded
+ * The string that contains the base32 encoded data.
+ * @param noOfBits
+ * How many bits to decode into binary data.
+ */
+ Base32(const string encoded, int noOfBits);
+
+ /**
+ * A Constructor that encodes binary data.
+ *
+ * The constructor converts the first specified number of bits of
+ * the binary data into a base32 presentation. Use
+ * <code>getEncoded</code> to get the encoded data.
+ *
+ * @param data
+ * A pointer to the first bits (byte) of binary data
+ * @param noOfBits
+ * How many bits to use for encoding. Should be a
+ * multiple of 5.
+ */
+ Base32(const unsigned char* data, int noOfBits);
+
+ ~Base32();
+
+ /**
+ * Get the decoded binary data and its length.
+ *
+ * The method returns the decoded binary data if the appropriate
+ * Constructor was used. Otherwise we return <code>NULL</code>
+ * pointer and length zero.
+ *
+ * <em>Note:</em> This method returns a pointer to the decoded
+ * binary data. The Base32 object manages this pointer, thus you
+ * may need to copy the data to a save place before deleting this
+ * object. If the object is deleted this pointer is no longer
+ * valid.
+ *
+ * @param length
+ * A reference to an integer.
+ * @return
+ * A pointer to the decoded binary data.
+ */
+ const unsigned char* getDecoded(int &length);
+
+ /**
+ * Get the encoded base32 string.
+ *
+ * The method returns a string that contains the base32 encoded
+ * data if the appropriate constructor was used. Otherwise we
+ * return an empty string.
+ *
+ * @return
+ * The string containing the base32 encoded data.
+ */
+ const string getEncoded() { return encoded; };
+
+ /**
+ * Compute the number of base32 encoded characters given the
+ * number of bits.
+ *
+ * @param lengthInBits
+ * The length of the data in bits
+ * @return
+ * The length of the base-32 encoding of the data in characters
+ */
+ static size_t const b2alen(const size_t lengthInBits) {
+ return divceil(lengthInBits, 5); };
+
+ private:
+
+ /**
+ * Decodes a string with base32 presentation into binary data.
+ *
+ * a2b_l() will return a result big enough to hold lengthinbits bits. So
+ * for example if cs is 4 characters long (encoding at least 15 and up to
+ * 20 bits) and lengthinbits is 16, then a2b_l() will return a string of
+ * length 2 (since 2 bytes is sufficient to store 16 bits). If cs is 4
+ * characters long and lengthinbits is 20, then a2b_l() will return a
+ * string of length 3 (since 3 bytes is sufficient to store 20 bits). Note
+ * that `b2a_l()' does not mask off unused least-significant bits, so for
+ * example if cs is 4 characters long and lengthinbits is 17, then you
+ * must ensure that all three of the unused least-significant bits of cs
+ * are zero bits or you will get the wrong result. This precondition is
+ * tested by assertions if assertions are enabled. (Generally you just
+ * require the encoder to ensure this consistency property between the
+ * least significant zero bits and value of `lengthinbits', and reject
+ * strings that have a length-in-bits which isn't a multiple of 8 and yet
+ * don't have trailing zero bits, as improperly encoded.)
+ *
+ * @param cs
+ * The data to be decoded
+ * @param size
+ * The length of the input data buffer. Usually divceil(length in bits, 5).
+ * @param lengthinbits
+ * The number of bits of data in <code>cs</code> to be decoded
+ */
+ void a2b_l(const string cs, size_t size, const size_t lengthinbits);
+
+ /**
+ * Encodes binary to to base32 presentation.
+ *
+ * b2a_l() will generate a base-32 encoded string big enough to encode
+ * lengthinbits bits. So for example if os is 2 bytes long and
+ * lengthinbits is 15, then b2a_l() will generate a 3-character- long
+ * base-32 encoded string (since 3 quintets is sufficient to encode 15
+ * bits). If os is 2 bytes long and lengthinbits is 16 (or None), then
+ * b2a_l() will generate a 4-character string. Note that `b2a_l()' does
+ * not mask off unused least-significant bits, so for example if os is 2
+ * bytes long and lengthinbits is 15, then you must ensure that the unused
+ * least-significant bit of os is a zero bit or you will get the wrong
+ * result. This precondition is tested by assertions if assertions are
+ * enabled.
+ *
+ * Warning: if you generate a base-32 encoded string with `b2a_l()', and
+ * then someone else tries to decode it by calling `a2b()' instead of
+ * `a2b_l()', then they will (probably) get a different string than the
+ * one you encoded! So only use `b2a_l()' when you are sure that the
+ * encoding and decoding sides know exactly which `lengthinbits' to use.
+ * If you do not have a way for the encoder and the decoder to agree upon
+ * the lengthinbits, then it is best to use `b2a()' and `a2b()'. The only
+ * drawback to using `b2a()' over `b2a_l()' is that when you have a number
+ * of bits to encode that is not a multiple of 8, `b2a()' can sometimes
+ * generate a base-32 encoded string that is one or two characters longer
+ * than necessary.
+ *
+ * @param cs
+ * Pointer to binary data.
+ * @param len
+ * Length of the binary data buffer. Usually (noOfBits+7)/8.
+ * @param noOfBits
+ * The number of bits of data in encoded into `cs'
+ */
+ void b2a_l(const unsigned char* cs, int len, const size_t noOfBits);
+
+ /**
+ * Holds the pointer to decoded binary data
+ */
+ unsigned char *binaryResult;
+
+ /**
+ * Length of decoding result
+ */
+ int resultLength;
+
+ /**
+ * The string containing the base32 encoded data.
+ */
+ string encoded;
+
+ unsigned char smallBuffer[128];
+};
+
+/**
+ * @}
+ */
+#endif
diff --git a/src/libzrtpcpp/CMakeLists.txt b/src/libzrtpcpp/CMakeLists.txt
new file mode 100755
index 0000000..099a233
--- /dev/null
+++ b/src/libzrtpcpp/CMakeLists.txt
@@ -0,0 +1,9 @@
+
+if(enable_ccrtp)
+ set(ccrtp_inst ZrtpQueue.h zrtpccrtp.h ZrtpUserCallback.h TimeoutProvider.h)
+endif()
+
+install(FILES
+ ZrtpCodes.h ZrtpConfigure.h ZrtpCallback.h ZrtpCWrapper.h
+ ${ccrtp_inst} DESTINATION include/libzrtpcpp)
+
diff --git a/src/libzrtpcpp/TimeoutProvider.h b/src/libzrtpcpp/TimeoutProvider.h
new file mode 100644
index 0000000..9f0edf7
--- /dev/null
+++ b/src/libzrtpcpp/TimeoutProvider.h
@@ -0,0 +1,303 @@
+/*
+ Copyright (C) 2006, 2005, 2004 Erik Eliasson, Johan Bilien, 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
+*/
+
+
+#ifndef TIMEOUTPROVIDER_H
+#define TIMEOUTPROVIDER_H
+
+/**
+ * Provides a way to request timeouts after a number of milli seconds.
+ *
+ * A command is associated to each timeout.
+ *
+ * Modified to use the common c++ library functions and the STL
+ * list by Werner Dittmann.
+ *
+ * @author Erik Eliasson, eliasson@it.kth.se, 2003
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <list>
+#include <sys/time.h>
+
+#include <commoncpp/config.h>
+#include <commoncpp/thread.h>
+
+/**
+ * Represents a request of a "timeout" (delivery of a command to a
+ * "timeout receiver" after at least a specified time period).
+ *
+ * Slightly modified to use gettimeofday directly.
+ *
+ * NOTE: This class is only used internaly.
+ * @author Erik Eliasson
+ * @author Werner Dittmann
+ */
+template <class TOCommand, class TOSubscriber>
+class TPRequest
+{
+
+public:
+
+ TPRequest( TOSubscriber tsi, int timeoutMs, const TOCommand &command):
+ subscriber(tsi)
+ {
+ struct timeval tv;
+ gettimeofday(&tv, NULL );
+
+ when_ms = ((uint64)tv.tv_sec) * (uint64)1000 + ((uint64)tv.tv_usec) / (uint64)1000;
+ when_ms += timeoutMs;
+ this->command = command;
+ }
+
+ /**
+ * @param t ms since Epoch
+ */
+ bool happensBefore(uint64 t)
+ {
+ if (when_ms < t) {
+ return true;
+ }
+ if (when_ms > t) {
+ return false;
+ }
+ return false; // if equal it does not "happens_before"
+
+ }
+
+ bool happensBefore(const TPRequest *req){
+ return happensBefore(req->when_ms);
+ }
+
+ /**
+ * Number of milli seconds until timeout from when this method is
+ * called
+ */
+ int getMsToTimeout ()
+ {
+ struct timeval tv;
+ gettimeofday(&tv, NULL );
+
+ uint64 now = ((uint64)tv.tv_sec) * (uint64)1000 + ((uint64)tv.tv_usec) / (uint64)1000;
+
+ if (happensBefore(now)) {
+ return 0;
+ }
+ else {
+ return (int)(when_ms - now);
+ }
+ }
+
+ TOCommand getCommand()
+ {
+ return command;
+ }
+
+ TOSubscriber getSubscriber()
+ {
+ return subscriber;
+ }
+
+ /**
+ * Two timeout requests are considered equeal if they have
+ * the same subscriber AND command AND time when they
+ * occur. If one of the time is zero then this is a
+ * wildcard and matches always.
+ */
+ bool operator==(const TPRequest<TOCommand, TOSubscriber> &req)
+ {
+ if (req.subscriber == subscriber &&
+ req.command == command &&
+ req.when_ms == when_ms) {
+ return true;
+ }
+ return false;
+ }
+
+private:
+ TOSubscriber subscriber;
+ uint64 when_ms; // Time since Epoch in ms when the timeout
+ // will happen
+
+ TOCommand command; // Command that will be delivered to the
+ // receiver (subscriber) of the timeout.
+};
+
+/**
+ * Class to generate objects giving timeout functionality.
+ *
+ * @author Erik Eliasson
+ * @author Werner Dittmann
+ */
+template<class TOCommand, class TOSubscriber>
+ class TimeoutProvider : public ost::Thread, ost::Event {
+
+public:
+
+ /**
+ * Timeout Provide Constructor
+ */
+ TimeoutProvider(): requests(), synchLock(), stop(false) { }
+
+ /**
+ * Destructor also terminates the Timeout thread.
+ */
+ ~TimeoutProvider() {
+ terminate();
+ }
+
+ /**
+ * Terminates the Timeout provider thread.
+ */
+ void stopThread(){
+ stop = true;
+ signal(); // signal event to waiting thread
+ }
+
+ /**
+ * Request a timeout trigger.
+ *
+ * @param time_ms Number of milli-seconds until the timeout is
+ * wanted. Note that a small additional period of time is
+ * added that depends on execution speed.
+ * @param subscriber The receiver of the callback when the command has timed
+ * out. This argument must not be NULL.
+ * @param command Specifies the String command to be passed back in the
+ * callback.
+ */
+ void requestTimeout(int32_t time_ms, TOSubscriber subscriber, const TOCommand &command)
+ {
+ TPRequest<TOCommand, TOSubscriber>* request =
+ new TPRequest<TOCommand, TOSubscriber>(subscriber, time_ms, command);
+
+ synchLock.enter();
+
+ if (requests.size()==0) {
+ requests.push_front(request);
+ signal();
+ synchLock.leave();
+ return;
+ }
+ if (request->happensBefore(requests.front())) {
+ requests.push_front(request);
+ signal();
+ synchLock.leave();
+ return;
+ }
+ if (requests.back()->happensBefore(request)){
+ requests.push_back(request);
+ signal();
+ synchLock.leave();
+ return;
+ }
+
+ typename std::list<TPRequest<TOCommand, TOSubscriber>* >::iterator i;
+ for(i = requests.begin(); i != requests.end(); i++ ) {
+ if( request->happensBefore(*i)) {
+ requests.insert(i, request);
+ break;
+ }
+ }
+ signal();
+ synchLock.leave();
+ }
+
+ /**
+ * Removes timeout requests that belong to a subscriber and command.
+ *
+ * @see requestTimeout
+ */
+ void cancelRequest(TOSubscriber subscriber, const TOCommand &command)
+ {
+ synchLock.enter();
+ typename std::list<TPRequest<TOCommand, TOSubscriber>* >::iterator i;
+ for(i = requests.begin(); i != requests.end(); ) {
+ if( (*i)->getCommand() == command &&
+ (*i)->getSubscriber() == subscriber) {
+ i = requests.erase(i);
+ continue;
+ }
+ i++;
+ }
+ synchLock.leave();
+ }
+
+protected:
+
+ void run()
+ {
+ do {
+ synchLock.enter();
+ int32_t time = 3600000;
+ int32_t size = 0;
+ if ((size = requests.size()) > 0) {
+ time = requests.front()->getMsToTimeout();
+ }
+ if (time == 0 && size > 0) {
+ if (stop){ // This must be checked so that we will
+ // stop even if we have timeouts to deliver.
+ synchLock.leave();
+ return;
+ }
+ TPRequest<TOCommand, TOSubscriber>* req = requests.front();
+ TOSubscriber subs = req->getSubscriber();
+ TOCommand command = req->getCommand();
+
+ requests.pop_front();
+
+ synchLock.leave(); // call the command with free Mutex
+ subs->handleTimeout(command);
+ continue;
+ }
+ synchLock.leave();
+ if (stop) { // If we were told to stop while delivering
+ // a timeout we will exit here
+ return;
+ }
+ reset(); // ready to receive triggers again
+ wait(time);
+ if (stop) { // If we are told to exit while waiting we
+ // will exit
+ return;
+ }
+ } while(true);
+ }
+
+private:
+
+ // The timeouts are ordered in the order of which they
+ // will expire. Nearest in future is first in list.
+ std::list<TPRequest<TOCommand, TOSubscriber> *> requests;
+
+ ost::Mutex synchLock; // Protects the internal data structures
+
+ bool stop; // Flag to tell the worker thread
+ // to terminate. Set to true and
+ // wake the worker thread to
+ // terminate it.
+};
+
+#endif
+
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-default-style: ellemtel
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/src/libzrtpcpp/ZIDFile.h b/src/libzrtpcpp/ZIDFile.h
new file mode 100644
index 0000000..0637c27
--- /dev/null
+++ b/src/libzrtpcpp/ZIDFile.h
@@ -0,0 +1,157 @@
+/*
+ Copyright (C) 2006-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/>.
+*/
+
+#include <stdio.h>
+
+#include <libzrtpcpp/ZIDRecord.h>
+
+#ifndef _ZIDFILE_H_
+#define _ZIDFILE_H_
+/**
+ * @file ZIDFile.h
+ * @brief ZID file management
+ *
+ * A ZID file stores (caches) some data that helps ZRTP to achives its
+ * key continuity feature. See @c ZIDRecord for further info which data
+ * the ZID file contains.
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+/**
+ * This class implements a ZID (ZRTP Identifiers) file.
+ *
+ * The ZID file holds information about peers.
+ *
+ * @author: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+class __EXPORT ZIDFile {
+
+private:
+
+ FILE* zidFile;
+ unsigned char associatedZid[IDENTIFIER_LEN];
+ /**
+ * The private ZID file constructor.
+ *
+ */
+ ZIDFile(): zidFile(NULL) {};
+ ~ZIDFile();
+ void createZIDFile(char* name);
+ void checkDoMigration(char* name);
+
+public:
+
+ /**
+ * Get the an instance of ZIDFile.
+ *
+ * This method just creates an instance an store a pointer to it
+ * in a static variable. The ZIDFile is a singleton, thus only
+ * <em>one</em> ZID file can be open at one time.
+ *
+ * @return
+ * A pointer to the global ZIDFile singleton instance.
+ */
+ static ZIDFile* getInstance();
+ /**
+ * Open the named ZID file and return a ZID file class.
+ *
+ * This static function either opens an existing ZID file or
+ * creates a new ZID file with the given name. The ZIDFile is a
+ * singleton, thus only <em>one</em> ZID file can be open at one
+ * time.
+ *
+ * To open another ZID file you must close the active ZID file
+ * first.
+ *
+ * @param name
+ * The name of the ZID file to open or create
+ * @return
+ * 1 if file could be opened/created, 0 if the ZID instance
+ * already has an open file, -1 if open/creation of file failed.
+ */
+ int open(char *name);
+
+ /**
+ * Check if ZIDFile has an active (open) file.
+ *
+ * @return
+ * True if ZIDFile has an active file, false otherwise
+ */
+ bool isOpen() { return (zidFile != NULL); };
+
+ /**
+ * Close the ZID file.
+ * Closes the ZID file, and prepares to open a new ZID file.
+ */
+ void close();
+
+ /**
+ * Get a ZID record from the active ZID file.
+ *
+ * The method get the identifier data from the ZID record parameter,
+ * locates the record in the ZID file and fills in the RS1, RS2, and
+ * other data.
+ *
+ * If no matching record exists in the ZID file the method creates
+ * it and fills it with default values.
+ *
+ * @param zidRecord
+ * The ZID record that contains the identifier data. The method
+ * fills in data .
+ * @return
+ * Currently always 1 to indicate sucess
+ */
+ unsigned int getRecord(ZIDRecord* zidRecord);
+
+ /**
+ * Save a ZID record into the active ZID file.
+ *
+ * This method saves the content of a ZID record into the ZID file. Before
+ * you can save the ZID record you must have performed a getRecord()
+ * first.
+ *
+ * @param zidRecord
+ * The ZID record to save.
+ * @return
+ * 1 on success
+ */
+ unsigned int saveRecord(ZIDRecord *zidRecord);
+
+ /**
+ * Get the ZID associated with this ZID file.
+ *
+ * @return
+ * Pointer to the ZID
+ */
+ const unsigned char* getZid() { return associatedZid; };
+};
+
+/**
+ * @}
+ */
+#endif
+
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-default-style: ellemtel
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/src/libzrtpcpp/ZIDRecord.h b/src/libzrtpcpp/ZIDRecord.h
new file mode 100644
index 0000000..eb2d190
--- /dev/null
+++ b/src/libzrtpcpp/ZIDRecord.h
@@ -0,0 +1,307 @@
+/*
+ Copyright (C) 2006-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 _ZIDRECORD_H_
+#define _ZIDRECORD_H_
+
+
+/**
+ * @file ZIDRecord.h
+ * @brief ZID record management
+ *
+ * A ZID record stores (caches) ZID (ZRTP ID) specific data that helps ZRTP
+ * to achives its key continuity feature. Please refer to the ZRTP
+ * specification to get detailed information about the ZID.
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <string.h>
+#include <stdint.h>
+
+#define IDENTIFIER_LEN 12
+#define RS_LENGTH 32
+#define TIME_LENGTH 8 // 64 bit, can hold time on 64 bit systems
+
+/**
+ * This is the recod structure of version 1 ZID records.
+ *
+ * This is not longer in use - only during migration.
+ */
+typedef struct zidrecord1 {
+ char recValid; //!< if 1 record is valid, if 0: invalid
+ char ownZid; //!< if >1 record contains own ZID, usually 1st record
+ char rs1Valid; //!< if 1 RS1 contains valid data
+ char rs2Valid; //!< if 1 RS2 contains valid data
+ unsigned char identifier[IDENTIFIER_LEN]; ///< the peer's ZID or own ZID
+ unsigned char rs1Data[RS_LENGTH], rs2Data[RS_LENGTH]; ///< the peer's RS data
+} zidrecord1_t;
+
+/**
+ * This is the recod structure of version 2 ZID records.
+ */
+typedef struct zidrecord2 {
+ char version; ///< version number of file format, this is #2
+ char flags; ///< bit field holding various flags, see below
+ char filler1; ///< round up to next 32 bit
+ char filler2; ///< round up to next 32 bit
+ unsigned char identifier[IDENTIFIER_LEN]; ///< the peer's ZID or own ZID
+ unsigned char rs1Interval[TIME_LENGTH]; ///< expiration time of RS1; -1 means indefinite
+ unsigned char rs1Data[RS_LENGTH]; ///< the peer's RS2 data
+ unsigned char rs2Interval[TIME_LENGTH]; ///< expiration time of RS2; -1 means indefinite
+ unsigned char rs2Data[RS_LENGTH]; ///< the peer's RS2 data
+ unsigned char mitmKey[RS_LENGTH]; ///< MiTM key if available
+} zidrecord2_t;
+
+
+#ifndef __EXPORT
+ #if __GNUC__ >= 4
+ #define __EXPORT __attribute__ ((visibility("default")))
+ #define __LOCAL __attribute__ ((visibility("hidden")))
+ #elif defined _WIN32 || defined __CYGWIN__
+ #define __EXPORT __declspec(dllimport)
+ #define __LOCAL
+ #else
+ #define __EXPORT
+ #define __LOCAL
+ #endif
+#endif
+
+static const int Valid = 0x1;
+static const int SASVerified = 0x2;
+static const int RS1Valid = 0x4;
+static const int RS2Valid = 0x8;
+static const int MITMKeyAvailable = 0x10;
+static const int OwnZIDRecord = 0x20;
+
+/**
+ * This class implements the ZID record.
+ *
+ * The ZID record holds data about a peer. According to ZRTP specification
+ * we use a ZID to identify a peer. ZRTP uses the RS (Retained Secret) data
+ * to construct shared secrets.
+ * <p>
+ * NOTE: ZIDRecord has ZIDFile as friend. ZIDFile knows about the private
+ * data of ZIDRecord - please keep both classes synchronized.
+ *
+ * @author: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+class __EXPORT ZIDRecord {
+ friend class ZIDFile;
+
+private:
+ zidrecord2_t record;
+ unsigned long position;
+
+ /*
+ * The default constructor is private
+ */
+ ZIDRecord() {
+ record.version = 2;
+ }
+
+ /**
+ * Functions for I/O availabe for ZID file handling
+ *
+ * These functions are private, thus only friends may use it.
+ */
+ void setPosition(long pos) {position = pos;}
+ long getPosition() {return position; }
+
+ zidrecord2_t* getRecordData() {return &record; }
+ int getRecordLength() {return sizeof(zidrecord2_t); }
+
+ bool isValid() { return ((record.flags & Valid) == Valid); }
+ void setValid() { record.flags |= Valid; }
+
+public:
+ /**
+ * Create a ZID Record with given ZID data
+ *
+ * The method creates a new ZID record and initializes its ZID
+ * data field. All other fields are set to null.
+ *
+ * An application can use this pre-initialized record to look
+ * up the associated record in the ZID file. If the record is
+ * available, the ZID record fields are filled with the stored
+ * data.
+ *
+ * @param idData
+ * Pointer to the fixed length ZID data
+ * @see ZIDFile::getRecord
+ */
+ ZIDRecord(const unsigned char *idData) {
+ memset(&record, 0, sizeof(zidrecord2_t));
+ memcpy(record.identifier, idData, IDENTIFIER_LEN);
+ record.version = 2;
+ }
+
+ /**
+ * Set @c valid flag in RS1
+ */
+ void setRs1Valid() { record.flags |= RS1Valid; }
+
+ /**
+ * reset @c valid flag in RS1
+ */
+ void resetRs1Valid() { record.flags &= ~RS1Valid; }
+
+ /**
+ * Check @c valid flag in RS1
+ */
+ bool isRs1Valid() { return ((record.flags & RS1Valid) == RS1Valid); }
+
+ /**
+ * Set @c valid flag in RS2
+ */
+ void setRs2Valid() { record.flags |= RS2Valid; }
+
+ /**
+ * Reset @c valid flag in RS2
+ */
+ void resetRs2Valid() { record.flags &= ~RS2Valid; }
+
+ /**
+ * Check @c valid flag in RS2
+ */
+ bool isRs2Valid() { return ((record.flags & RS2Valid) == RS2Valid); }
+
+ /**
+ * Set MITM key available
+ */
+ void setMITMKeyAvailable() { record.flags |= MITMKeyAvailable; }
+
+ /**
+ * Reset MITM key available
+ */
+ void resetMITMKeyAvailable() { record.flags &= ~MITMKeyAvailable; }
+
+ /**
+ * Check MITM key available is set
+ */
+ bool isMITMKeyAvailable() { return ((record.flags & MITMKeyAvailable) == MITMKeyAvailable); }
+
+ /**
+ * Mark this as own ZID record
+ */
+ void setOwnZIDRecord() { record.flags = OwnZIDRecord; }
+ /**
+ * Reset own ZID record marker
+ */
+ void resetOwnZIDRecord(){ record.flags = 0; }
+
+ /**
+ * Check own ZID record marker
+ */
+ bool isOwnZIDRecord() { return (record.flags == OwnZIDRecord); } // no other flag allowed if own ZID
+
+ /**
+ * Set SAS for this ZID as verified
+ */
+ void setSasVerified() { record.flags |= SASVerified; }
+ /**
+ * Reset SAS for this ZID as verified
+ */
+ void resetSasVerified() { record.flags &= ~SASVerified; }
+
+ /**
+ * Check if SAS for this ZID was verified
+ */
+ bool isSasVerified() { return ((record.flags & SASVerified) == SASVerified); }
+
+ /**
+ * Return the ZID for this record
+ */
+ const uint8_t* getIdentifier() {return record.identifier; }
+
+ /**
+ * Check if RS1 is still valid
+ *
+ * Returns true if RS1 is still valid, false otherwise.
+ *
+ * @return
+ * Returns true is RS1 is not expired (valid), false otherwise.
+ */
+ const bool isRs1NotExpired();
+
+ /**
+ * Returns pointer to RS1 data.
+ */
+ const unsigned char* getRs1() { return record.rs1Data; }
+
+ /**
+ * Check if RS2 is still valid
+ *
+ * Returns true if RS2 is still valid, false otherwise.
+ *
+ * @return
+ * Returns true is RS2 is not expired (valid), false otherwise.
+ */
+ const bool isRs2NotExpired();
+
+ /**
+ * Returns pointer to RS1 data.
+ */
+ const unsigned char* getRs2() { return record.rs2Data; }
+
+ /**
+ * Sets new RS1 data and associated expiration value.
+ *
+ * If the expiration value is >0 or -1 the method stores the new
+ * RS1. Before it stores the new RS1 it shifts the exiting RS1
+ * into RS2 (together with its expiration time). Then it computes
+ * the expiration time of the and stores the result together with
+ * the new RS1.
+ *
+ * If the expiration value is -1 then this RS will never expire.
+ *
+ * If the expiration value is 0 then the expiration value of a
+ * stored RS1 is cleared and no new RS1 value is stored. Also RS2
+ * is left unchanged.
+ *
+ * @param data
+ * Points to the new RS1 data.
+ * @param expire
+ * The expiration interval in seconds. Default is -1.
+ *
+ */
+ void setNewRs1(const unsigned char* data, int32_t expire =-1);
+
+ /**
+ * Set MiTM key data.
+ *
+ */
+ void setMiTMData(const unsigned char* data);
+
+ /**
+ * Get MiTM key data.
+ *
+ */
+ const unsigned char* getMiTMData() {return record.mitmKey; }
+};
+
+#endif // ZIDRECORD
+
+
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-default-style: ellemtel
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/src/libzrtpcpp/ZRtp.h b/src/libzrtpcpp/ZRtp.h
new file mode 100644
index 0000000..4e03f28
--- /dev/null
+++ b/src/libzrtpcpp/ZRtp.h
@@ -0,0 +1,1292 @@
+/*
+ Copyright (C) 2006-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 _ZRTP_H_
+#define _ZRTP_H_
+/**
+ * @file ZRtp.h
+ * @brief The ZRTP main engine
+ * @defgroup GNU_ZRTP The GNU ZRTP C++ implementation
+ * @{
+ */
+
+#include <cstdlib>
+
+#include <libzrtpcpp/ZrtpPacketHello.h>
+#include <libzrtpcpp/ZrtpPacketHelloAck.h>
+#include <libzrtpcpp/ZrtpPacketCommit.h>
+#include <libzrtpcpp/ZrtpPacketDHPart.h>
+#include <libzrtpcpp/ZrtpPacketConfirm.h>
+#include <libzrtpcpp/ZrtpPacketConf2Ack.h>
+#include <libzrtpcpp/ZrtpPacketGoClear.h>
+#include <libzrtpcpp/ZrtpPacketClearAck.h>
+#include <libzrtpcpp/ZrtpPacketError.h>
+#include <libzrtpcpp/ZrtpPacketErrorAck.h>
+#include <libzrtpcpp/ZrtpPacketPing.h>
+#include <libzrtpcpp/ZrtpPacketPingAck.h>
+#include <libzrtpcpp/ZrtpPacketSASrelay.h>
+#include <libzrtpcpp/ZrtpPacketRelayAck.h>
+#include <libzrtpcpp/ZrtpCallback.h>
+#include <libzrtpcpp/ZIDRecord.h>
+
+#ifndef SHA256_DIGEST_LENGTH
+#define SHA256_DIGEST_LENGTH 32
+#endif
+
+// Prepare to support digest algorithms up to 512 bit (64 bytes)
+#define MAX_DIGEST_LENGTH 64
+#define IMPL_MAX_DIGEST_LENGTH 64
+
+class __EXPORT ZrtpStateClass;
+class ZrtpDH;
+
+/**
+ * The main ZRTP class.
+ *
+ * This is the main class of the RTP/SRTP independent part of the GNU
+ * ZRTP. It handles the ZRTP HMAC, DH, and other data management. The
+ * user of this class needs to know only a few methods and needs to
+ * provide only a few external functions to connect to a Timer
+ * mechanism and to send data via RTP and SRTP. Refer to the
+ * ZrtpCallback class to get detailed information regading the
+ * callback methods required by GNU RTP.
+ *
+ * The class ZrtpQueue is the GNU ccRTP specific implementation that
+ * extends standard ccRTP RTP provide ZRTP support. Refer to the
+ * documentation of ZrtpQueue to get more information about the usage
+ * of ZRtp and associated classes.
+ *
+ * The main entry into the ZRTP class is the processExtensionHeader()
+ * method.
+ *
+ * This class does not directly handle the protocol states, timers,
+ * and packet resend. The protocol state engine is responsible for
+ * these actions.
+ *
+ * Example how to use ZRtp:
+ *<pre>
+ * zrtpEngine = new ZRtp((uint8_t*)ownZid, (ZrtpCallback*)this, idString);
+ * zrtpEngine->startZrtpEngine();
+ *</pre>
+ * @see ZrtpCallback
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+class __EXPORT ZRtp {
+
+ public:
+
+ /**
+ * Constructor intializes all relevant data but does not start the
+ * engine.
+ */
+ ZRtp(uint8_t* myZid, ZrtpCallback* cb, std::string id,
+ ZrtpConfigure* config, bool mitmm= false, bool sasSignSupport= false);
+
+ /**
+ * Destructor cleans up.
+ */
+ ~ZRtp();
+
+ /**
+ * Kick off the ZRTP protocol engine.
+ *
+ * This method calls the ZrtpStateClass#evInitial() state of the state
+ * engine. After this call we are able to process ZRTP packets
+ * from our peer and to process them.
+ */
+ void startZrtpEngine();
+
+ /**
+ * Stop ZRTP security.
+ *
+ */
+ void stopZrtp();
+
+ /**
+ * Process RTP extension header.
+ *
+ * This method expects to get a pointer to the extension header of
+ * a RTP packet. The method checks if this is really a ZRTP
+ * packet. If this check fails the method returns 0 (false) in
+ * case this is not a ZRTP packet. We return a 1 if we processed
+ * the ZRTP extension header and the caller may process RTP data
+ * after the extension header as usual. The method return -1 the
+ * call shall dismiss the packet and shall not forward it to
+ * further RTP processing.
+ *
+ * @param extHeader
+ * A pointer to the first byte of the extension header. Refer to
+ * RFC3550.
+ * @param peerSSRC
+ * The peer's SSRC.
+ * @return
+ * Code indicating further packet handling, see description above.
+ */
+ void processZrtpMessage(uint8_t *extHeader, uint32_t peerSSRC);
+
+ /**
+ * Process a timeout event.
+ *
+ * We got a timeout from the timeout provider. Forward it to the
+ * protocol state engine.
+ *
+ */
+ void processTimeout();
+
+ /**
+ * Check for and handle GoClear ZRTP packet header.
+ *
+ * This method checks if this is a GoClear packet. If not, just return
+ * false. Otherwise handle it according to the specification.
+ *
+ * @param extHeader
+ * A pointer to the first byte of the extension header. Refer to
+ * RFC3550.
+ * @return
+ * False if not a GoClear, true otherwise.
+ */
+ bool handleGoClear(uint8_t *extHeader);
+
+ /**
+ * Set the auxilliary secret.
+ *
+ * Use this method to set the auxilliary secret data. Refer to ZRTP
+ * specification, chapter 4.3 ff
+ *
+ * @param data
+ * Points to the secret data.
+ * @param length
+ * Length of the auxilliary secrect in bytes
+ */
+ void setAuxSecret(uint8_t* data, int32_t length);
+
+ /**
+ * Check current state of the ZRTP state engine
+ *
+ * @param state
+ * The state to check.
+ * @return
+ * Returns true id ZRTP engine is in the given state, false otherwise.
+ */
+ bool inState(int32_t state);
+
+ /**
+ * Set SAS as verified.
+ *
+ * Call this method if the user confirmed (verfied) the SAS. ZRTP
+ * remembers this together with the retained secrets data.
+ */
+ void SASVerified();
+
+ /**
+ * Reset the SAS verfied flag for the current active user's retained secrets.
+ *
+ */
+ void resetSASVerified();
+
+ /**
+ * Get the ZRTP Hello Hash data.
+ *
+ * Use this method to get the ZRTP Hello Hash data. The method
+ * returns the data as a string containing the ZRTP protocol version and
+ * hex-digits.
+ *
+ * Refer to ZRTP specification, chapter 8.
+ *
+ * @return
+ * a std:string containing the Hello hash value as hex-digits. The
+ * hello hash is available immediately after class instantiation.
+ */
+ std::string getHelloHash();
+
+ /**
+ * Get the peer's ZRTP Hello Hash data.
+ *
+ * Use this method to get the peer's ZRTP Hello Hash data. The method
+ * returns the data as a string containing the ZRTP protocol version and
+ * hex-digits.
+ *
+ * The peer's hello hash is available only after ZRTP received a hello. If
+ * no data is available the function returns an empty string.
+ *
+ * Refer to ZRTP specification, chapter 8.
+ *
+ * @return
+ * a std:string containing the Hello version and the hello hash as hex digits.
+ */
+ std::string getPeerHelloHash();
+
+ /**
+ * Get Multi-stream parameters.
+ *
+ * Use this method to get the Multi-stream that were computed during
+ * the ZRTP handshake. An application may use these parameters to
+ * enable multi-stream processing for an associated SRTP session.
+ *
+ * Refer to chapter 4.4.2 in the ZRTP specification for further details
+ * and restriction how and when to use multi-stream mode.
+ *
+ * @return
+ * a string that contains the multi-stream parameters. The application
+ * must not modify the contents of this string, it is opaque data. The
+ * application may hand over this string to a new ZrtpQueue instance
+ * to enable multi-stream processing for this ZrtpQueue.
+ * If ZRTP was not started or ZRTP is not yet in secure state the method
+ * returns an empty string.
+ */
+ std::string getMultiStrParams();
+
+ /**
+ * Set Multi-stream parameters.
+ *
+ * Use this method to set the parameters required to enable Multi-stream
+ * processing of ZRTP. The multi-stream parameters must be set before the
+ * application starts the ZRTP protocol engine.
+ *
+ * Refer to chapter 4.4.2 in the ZRTP specification for further details
+ * of multi-stream mode.
+ *
+ * @param parameters
+ * A string that contains the multi-stream parameters that this
+ * new ZrtpQueue instanace shall use. See also
+ * <code>getMultiStrParams()</code>
+ */
+ void setMultiStrParams(std::string parameters);
+
+ /**
+ * Check if this ZRTP session is a Multi-stream session.
+ *
+ * Use this method to check if this ZRTP instance uses multi-stream.
+ * Refer to chapters 4.2 and 4.4.2 in the ZRTP.
+ *
+ * @return
+ * True if multi-stream is used, false otherwise.
+ */
+ bool isMultiStream();
+
+ /**
+ * Check if the other ZRTP client supports Multi-stream.
+ *
+ * Use this method to check if the other ZRTP client supports
+ * Multi-stream mode.
+ *
+ * @return
+ * True if multi-stream is available, false otherwise.
+ */
+ bool isMultiStreamAvailable();
+
+ /**
+ * Accept a PBX enrollment request.
+ *
+ * If a PBX service asks to enroll the PBX trusted MitM key and the user
+ * accepts this request, for example by pressing an OK button, the client
+ * application shall call this method and set the parameter
+ * <code>accepted</code> to true. If the user does not accept the request
+ * set the parameter to false.
+ *
+ * @param accepted
+ * True if the enrollment request is accepted, false otherwise.
+ */
+ void acceptEnrollment(bool accepted);
+
+ /**
+ * Check the state of the enrollment mode.
+ *
+ * If true then we will set the enrollment flag (E) in the confirm
+ * packets and perform the enrollment actions. A MitM (PBX) enrollment service
+ * started this ZRTP session. Can be set to true only if mitmMode is also true.
+ *
+ * @return status of the enrollmentMode flag.
+ */
+ bool isEnrollmentMode();
+
+ /**
+ * Set the state of the enrollment mode.
+ *
+ * If true then we will set the enrollment flag (E) in the confirm
+ * packets and perform the enrollment actions. A MitM (PBX) enrollment
+ * service must sets this mode to true.
+ *
+ * Can be set to true only if mitmMode is also true.
+ *
+ * @param enrollmentMode defines the new state of the enrollmentMode flag
+ */
+ void setEnrollmentMode(bool enrollmentMode);
+
+ /**
+ * Check if a peer's cache entry has a vaild MitM key.
+ *
+ * If true then the other peer ha a valid MtiM key, i.e. the peer has performed
+ * the enrollment procedure. A PBX ZRTP Back-2-Back application can use this function
+ * to check which of the peers is enrolled.
+ *
+ * @return True if the other peer has a valid Mitm key (is enrolled).
+ */
+ bool isPeerEnrolled();
+
+ /**
+ * Send the SAS relay packet.
+ *
+ * The method creates and sends a SAS relay packet according to the ZRTP
+ * specifications. Usually only a MitM capable user agent (PBX) uses this
+ * function.
+ *
+ * @param sh the full SAS hash value, 32 bytes
+ * @param render the SAS rendering algorithm
+ */
+ bool sendSASRelayPacket(uint8_t* sh, std::string render);
+
+ /**
+ * Get the commited SAS rendering algorithm for this ZRTP session.
+ *
+ * @return the commited SAS rendering algorithm
+ */
+ std::string getSasType();
+
+ /**
+ * Get the computed SAS hash for this ZRTP session.
+ *
+ * A PBX ZRTP back-to-Back function uses this function to get the SAS
+ * hash of an enrolled client to construct the SAS relay packet for
+ * the other client.
+ *
+ * @return a pointer to the byte array that contains the full
+ * SAS hash.
+ */
+ uint8_t* getSasHash();
+
+ /**
+ * Set signature data.
+ *
+ * This functions stores signature data and transmitts it during ZRTP
+ * processing to the other party as part of the Confirm packets. Refer to
+ * chapters 5.7 and 7.2.
+ *
+ * The signature data must be set before ZRTP the application calls
+ * <code>start()</code>.
+ *
+ * @param data
+ * The signature data including the signature type block. The method
+ * copies this data into the Confirm packet at signature type block.
+ * @param length
+ * The length of the signature data in bytes. This length must be
+ * multiple of 4.
+ * @return
+ * True if the method stored the data, false otherwise.
+ */
+ bool setSignatureData(uint8_t* data, int32_t length);
+
+ /**
+ * Get signature data.
+ *
+ * This functions returns a pointer to the signature data that was receivied
+ * during ZRTP processing. Refer to chapters 5.7 and 7.2.
+ *
+ * The returned pointer points to volatile data that is valid only during the
+ * <code>checkSASSignature()</code> callback funtion. The application must copy
+ * the signature data if it will be used after the callback function returns.
+ *
+ * The signature data can be retrieved after ZRTP enters secure state.
+ * <code>start()</code>.
+ *
+ * @return
+ * Pointer to signature data.
+ */
+ const uint8_t* getSignatureData();
+
+ /**
+ * Get length of signature data in number of bytes.
+ *
+ * This functions returns the length of signature data that was receivied
+ * during ZRTP processing. Refer to chapters 5.7 and 7.2.
+ *
+ * @return
+ * Length in bytes of the received signature data. The method returns
+ * zero if no signature data is avilable.
+ */
+ int32_t getSignatureLength();
+
+ /**
+ * Emulate a Conf2Ack packet.
+ *
+ * This method emulates a Conf2Ack packet. According to ZRTP specification
+ * the first valid SRTP packet that the Initiator receives must switch
+ * on secure mode. Refer to chapter 4 in the specificaton
+ *
+ */
+ void conf2AckSecure();
+
+ /**
+ * Get other party's ZID (ZRTP Identifier) data
+ *
+ * This functions returns the other party's ZID that was receivied
+ * during ZRTP processing.
+ *
+ * The ZID data can be retrieved after ZRTP receive the first Hello
+ * packet from the other party. The application may call this method
+ * for example during SAS processing in showSAS(...) user callback
+ * method.
+ *
+ * @param data
+ * Pointer to a data buffer. This buffer must have a size of
+ * at least 12 bytes (96 bit) (ZRTP Identifier, see chap. 4.9)
+ * @return
+ * Number of bytes copied into the data buffer - must be equivalent
+ * to 96 bit, usually 12 bytes.
+ */
+ int32_t getPeerZid(uint8_t* data);
+
+private:
+ friend class ZrtpStateClass;
+
+ /**
+ * The state engine takes care of protocol processing.
+ */
+ ZrtpStateClass* stateEngine;
+
+ /**
+ * This is my ZID that I send to the peer.
+ */
+ uint8_t zid[IDENTIFIER_LEN];
+
+ /**
+ * The peer's ZID
+ */
+ uint8_t peerZid[IDENTIFIER_LEN];
+
+ /**
+ * The callback class provides me with the interface to send
+ * data and to deal with timer management of the hosting system.
+ */
+ ZrtpCallback* callback;
+
+ /**
+ * My active Diffie-Helman context
+ */
+ ZrtpDH* dhContext;
+
+ /**
+ * The computed DH shared secret
+ */
+ uint8_t* DHss;
+
+ /**
+ * My computed public key
+ */
+ uint8_t pubKeyBytes[400];
+ /**
+ * Length off public key
+ */
+// int32_t pubKeyLen;
+ /**
+ * My Role in the game
+ */
+ Role myRole;
+
+ /**
+ * The human readable SAS value
+ */
+ std::string SAS;
+
+ /**
+ * The SAS hash for signaling and alike. Refer to chapters
+ * 4.5 and 7 how sasHash, sasValue and the SAS string are derived.
+ */
+ uint8_t sasHash[MAX_DIGEST_LENGTH];
+ /**
+ * The ids for the retained and other shared secrets
+ */
+ uint8_t rs1IDr[MAX_DIGEST_LENGTH];
+ uint8_t rs2IDr[MAX_DIGEST_LENGTH];
+ uint8_t auxSecretIDr[MAX_DIGEST_LENGTH];
+ uint8_t pbxSecretIDr[MAX_DIGEST_LENGTH];
+
+ uint8_t rs1IDi[MAX_DIGEST_LENGTH];
+ uint8_t rs2IDi[MAX_DIGEST_LENGTH];
+ uint8_t auxSecretIDi[MAX_DIGEST_LENGTH];
+ uint8_t pbxSecretIDi[MAX_DIGEST_LENGTH];
+
+ /**
+ * pointers to aux secret storage and length of aux secret
+ */
+ uint8_t* auxSecret;
+ int32_t auxSecretLength;
+
+ /**
+ * Record if valid rs1 and/or rs1 were found in the
+ * retaind secret cache.
+ */
+ bool rs1Valid;
+ bool rs2Valid;
+ /**
+ * My hvi
+ */
+ uint8_t hvi[MAX_DIGEST_LENGTH];
+
+ /**
+ * The peer's hvi
+ */
+ uint8_t peerHvi[8*ZRTP_WORD_SIZE];
+
+ /**
+ * Context to compute the SHA256 hash of selected messages.
+ * Used to compute the s0, refer to chapter 4.4.1.4
+ */
+ void* msgShaContext;
+ /**
+ * Commited Hash, Cipher, and public key algorithms
+ */
+ AlgorithmEnum* hash;
+ AlgorithmEnum* cipher;
+ AlgorithmEnum* pubKey;
+ /**
+ * The selected SAS type.
+ */
+ AlgorithmEnum* sasType;
+
+ /**
+ * The selected SAS type.
+ */
+ AlgorithmEnum* authLength;
+
+ /**
+ * The Hash images as defined in chapter 5.1.1 (H0 is a random value,
+ * not stored here). Need full SHA 256 lenght to store hash value but
+ * only the leftmost 128 bits are used in computations and comparisons.
+ */
+ uint8_t H0[IMPL_MAX_DIGEST_LENGTH];
+ uint8_t H1[IMPL_MAX_DIGEST_LENGTH];
+ uint8_t H2[IMPL_MAX_DIGEST_LENGTH];
+ uint8_t H3[IMPL_MAX_DIGEST_LENGTH];
+ uint8_t helloHash[IMPL_MAX_DIGEST_LENGTH];
+
+ uint8_t peerHelloHash[IMPL_MAX_DIGEST_LENGTH];
+ uint8_t peerHelloVersion[ZRTP_WORD_SIZE + 1]; // +1 for nul byte
+
+ // We get the peer's H? from the message where length is defined as 8 words
+ uint8_t peerH0[8*ZRTP_WORD_SIZE];
+ uint8_t peerH1[8*ZRTP_WORD_SIZE];
+ uint8_t peerH2[8*ZRTP_WORD_SIZE];
+ uint8_t peerH3[8*ZRTP_WORD_SIZE];
+
+ /**
+ * The SHA256 hash over selected messages
+ */
+ uint8_t messageHash[MAX_DIGEST_LENGTH];
+
+ /**
+ * The s0
+ */
+ uint8_t s0[MAX_DIGEST_LENGTH];
+
+ /**
+ * The new Retained Secret
+ */
+ uint8_t newRs1[MAX_DIGEST_LENGTH];
+
+ /**
+ * The GoClear HMAC keys and confirm HMAC key
+ */
+ uint8_t hmacKeyI[MAX_DIGEST_LENGTH];
+ uint8_t hmacKeyR[MAX_DIGEST_LENGTH];
+
+ /**
+ * The Initiator's srtp key and salt
+ */
+ uint8_t srtpKeyI[MAX_DIGEST_LENGTH];
+ uint8_t srtpSaltI[MAX_DIGEST_LENGTH];
+
+ /**
+ * The Responder's srtp key and salt
+ */
+ uint8_t srtpKeyR[MAX_DIGEST_LENGTH];
+ uint8_t srtpSaltR[MAX_DIGEST_LENGTH];
+
+ /**
+ * The keys used to encrypt/decrypt the confirm message
+ */
+ uint8_t zrtpKeyI[MAX_DIGEST_LENGTH];
+ uint8_t zrtpKeyR[MAX_DIGEST_LENGTH];
+
+ /**
+ * Pointers to negotiated hash and HMAC functions
+ */
+ void (*hashFunction)(unsigned char *data,
+ unsigned int data_length,
+ unsigned char *digest);
+
+ void (*hashListFunction)(unsigned char *data[],
+ unsigned int data_length[],
+ unsigned char *digest);
+
+ void (*hmacFunction)(uint8_t* key, uint32_t key_length,
+ uint8_t* data, int32_t data_length,
+ uint8_t* mac, uint32_t* mac_length);
+
+ void (*hmacListFunction)( uint8_t* key, uint32_t key_length,
+ uint8_t* data[], uint32_t data_length[],
+ uint8_t* mac, uint32_t* mac_length );
+
+ void* (*createHashCtx)();
+
+ void (*closeHashCtx)(void* ctx, unsigned char* digest);
+
+ void (*hashCtxFunction)(void* ctx, unsigned char* data,
+ unsigned int dataLength);
+
+ void (*hashCtxListFunction)(void* ctx, unsigned char* dataChunks[],
+ unsigned int dataChunkLength[]);
+
+ int32_t hashLength;
+
+ // Funtion pointers to implicit hash and hmac functions
+ void (*hashFunctionImpl)(unsigned char *data,
+ unsigned int data_length,
+ unsigned char *digest);
+
+ void (*hashListFunctionImpl)(unsigned char *data[],
+ unsigned int data_length[],
+ unsigned char *digest);
+
+ void (*hmacFunctionImpl)(uint8_t* key, uint32_t key_length,
+ uint8_t* data, int32_t data_length,
+ uint8_t* mac, uint32_t* mac_length);
+
+ void (*hmacListFunctionImpl)( uint8_t* key, uint32_t key_length,
+ uint8_t* data[], uint32_t data_length[],
+ uint8_t* mac, uint32_t* mac_length );
+
+ int32_t hashLengthImpl;
+
+ /**
+ * The ZRTP Session Key
+ * Refer to chapter 5.4.1.4
+ */
+ uint8_t zrtpSession[MAX_DIGEST_LENGTH];
+
+ /**
+ * True if this ZRTP instance uses multi-stream mode.
+ */
+ bool multiStream;
+
+ /**
+ * True if the other ZRTP client supports multi-stream mode.
+ */
+ bool multiStreamAvailable;
+
+ /**
+ * Enable MitM (PBX) enrollment
+ *
+ * If set to true then ZRTP honors the PBX enrollment flag in
+ * Commit packets and calls the appropriate user callback
+ * methods. If the parameter is set to false ZRTP ignores the PBX
+ * enrollment flags.
+ */
+ bool enableMitmEnrollment;
+
+ /**
+ * True if a valid trusted MitM key of the other peer is available, i.e. enrolled.
+ */
+ bool peerIsEnrolled;
+
+ /**
+ * Set to true if the Hello packet contained the M-flag (MitM flag).
+ * We use this later to check some stuff for SAS Relay processing
+ */
+ bool mitmSeen;
+
+ /**
+ * Temporarily store computed pbxSecret, if user accepts enrollment then
+ * it will copied to our ZID record of the PBX (MitM)
+ */
+ uint8_t* pbxSecretTmp;
+ uint8_t pbxSecretTmpBuffer[MAX_DIGEST_LENGTH];
+
+ /**
+ * If true then we will set the enrollment flag (E) in the confirm
+ * packets. Set to true if the PBX enrollment service started this ZRTP
+ * session. Can be set to true only if mitmMode is also true.
+ */
+ bool enrollmentMode;
+
+ /**
+ * Configuration data which algorithms to use.
+ */
+ ZrtpConfigure configureAlgos;
+ /**
+ * Pre-initialized packets.
+ */
+ ZrtpPacketHello zrtpHello;
+ ZrtpPacketHelloAck zrtpHelloAck;
+ ZrtpPacketConf2Ack zrtpConf2Ack;
+ ZrtpPacketClearAck zrtpClearAck;
+ ZrtpPacketGoClear zrtpGoClear;
+ ZrtpPacketError zrtpError;
+ ZrtpPacketErrorAck zrtpErrorAck;
+ ZrtpPacketDHPart zrtpDH1;
+ ZrtpPacketDHPart zrtpDH2;
+ ZrtpPacketCommit zrtpCommit;
+ ZrtpPacketConfirm zrtpConfirm1;
+ ZrtpPacketConfirm zrtpConfirm2;
+ ZrtpPacketPingAck zrtpPingAck;
+ ZrtpPacketSASrelay zrtpSasRelay;
+ ZrtpPacketRelayAck zrtpRelayAck;
+
+ /**
+ * Random IV data to encrypt the confirm data, 128 bit for AES
+ */
+ uint8_t randomIV[16];
+
+ uint8_t tempMsgBuffer[1024];
+ int32_t lengthOfMsgData;
+
+ /**
+ * Variables to store signature data. Includes the signature type block
+ */
+ const uint8_t* signatureData; // will be set when needed
+ int32_t signatureLength; // overall length in bytes
+
+ /**
+ * Is true if the other peer signaled SAS signature support in its Hello packet.
+ */
+ bool signSasSeen;
+
+ uint32_t peerSSRC; // peer's SSRC, required to setup PingAck packet
+
+ /**
+ * Enable or disable paranoid mode.
+ *
+ * The Paranoid mode controls the behaviour and handling of the SAS verify flag. If
+ * Panaoid mode is set to flase then ZRtp applies the normal handling. If Paranoid
+ * mode is set to true then the handling is:
+ *
+ * <ul>
+ * <li> Force the SAS verify flag to be false at srtpSecretsOn() callback. This gives
+ * the user interface (UI) the indication to handle the SAS as <b>not verified</b>.
+ * See implementation note below.</li>
+ * <li> Don't set the SAS verify flag in the <code>Confirm</code> packets, thus the other
+ * also must report the SAS as <b>not verified</b>.</li>
+ * <li> ignore the <code>SASVerified()</code> function, thus do not set the SAS to verified
+ * in the ZRTP cache. </li>
+ * <li> Disable the <b>Trusted PBX MitM</b> feature. Just send the <code>SASRelay</code> packet
+ * but do not process the relayed data. This protects the user from a malicious
+ * "trusted PBX".</li>
+ * </ul>
+ * ZRtp performs alls other steps during the ZRTP negotiations as usual, in particular it
+ * computes, compares, uses, and stores the retained secrets. This avoids unnecessary warning
+ * messages. The user may enable or disable the Paranoid mode on a call-by-call basis without
+ * breaking the key continuity data.
+ *
+ * <b>Implementation note:</b></br>
+ * An application shall always display the SAS code if the SAS verify flag is <code>false</code>.
+ * The application shall also use mechanisms to remind the user to compare the SAS code, for
+ * example useing larger fonts, different colours and other display features.
+ */
+ bool paranoidMode;
+
+ /**
+ * Find the best Hash algorithm that is offered in Hello.
+ *
+ * Find the best, that is the strongest, Hash algorithm that our peer
+ * offers in its Hello packet.
+ *
+ * @param hello
+ * The Hello packet.
+ * @return
+ * The Enum that identifies the best offered Hash algortihm. Return
+ * <code>NumSupportedHashes</code> to signal that no matching Hash algorithm
+ * was found at all.
+ */
+ AlgorithmEnum* findBestHash(ZrtpPacketHello *hello);
+
+ /**
+ * Find the best symmetric cipher algorithm that is offered in Hello.
+ *
+ * Find the best, that is the strongest, cipher algorithm that our peer
+ * offers in its Hello packet.
+ *
+ * @param hello
+ * The Hello packet.
+ * @param pk
+ * The id of the selected public key algorithm
+ * @return
+ * The Enum that identifies the best offered Cipher algortihm. Return
+ * <code>NumSupportedSymCiphers</code> to signal that no matching Cipher algorithm
+ * was found at all.
+ */
+ AlgorithmEnum* findBestCipher(ZrtpPacketHello *hello, AlgorithmEnum* pk);
+
+ /**
+ * Find the best Public Key algorithm that is offered in Hello.
+ *
+ * Find the best, that is the strongest, public key algorithm that our peer
+ * offers in its Hello packet.
+ *
+ * @param hello
+ * The Hello packet.
+ * @return
+ * The Enum that identifies the best offered Public Key algortihm. Return
+ * <code>NumSupportedPubKeys</code> to signal that no matching Public Key algorithm
+ * was found at all.
+ */
+ AlgorithmEnum* findBestPubkey(ZrtpPacketHello *hello);
+
+ /**
+ * Find the best SAS algorithm that is offered in Hello.
+ *
+ * Find the best, that is the strongest, SAS algorithm that our peer
+ * offers in its Hello packet.
+ *
+ * @param hello
+ * The Hello packet.
+ * @return
+ * The Enum that identifies the best offered SAS algortihm. Return
+ * <code>NumSupportedSASTypes</code> to signal that no matching SAS algorithm
+ * was found at all.
+ */
+ AlgorithmEnum* findBestSASType(ZrtpPacketHello* hello);
+
+ /**
+ * Find the best authentication length that is offered in Hello.
+ *
+ * Find the best, that is the strongest, authentication length that our peer
+ * offers in its Hello packet.
+ *
+ * @param hello
+ * The Hello packet.
+ * @return
+ * The Enum that identifies the best offered authentication length. Return
+ * <code>NumSupportedAuthLenghts</code> to signal that no matching length
+ * was found at all.
+ */
+ AlgorithmEnum* findBestAuthLen(ZrtpPacketHello* hello);
+
+ /**
+ * Check if MultiStream mode is offered in Hello.
+ *
+ * Find the best, that is the strongest, authentication length that our peer
+ * offers in its Hello packet.
+ *
+ * @param hello
+ * The Hello packet.
+ * @return
+ * True if multi stream mode is available, false otherwise.
+ */
+ bool checkMultiStream(ZrtpPacketHello* hello);
+
+ /**
+ * Save the computed MitM secret to the ZID record of the peer
+ */
+ void writeEnrollmentPBX();
+
+ /**
+ * Compute my hvi value according to ZRTP specification.
+ */
+ void computeHvi(ZrtpPacketDHPart* dh, ZrtpPacketHello *hello);
+
+ void computeSharedSecretSet(ZIDRecord& zidRec);
+
+ void computeSRTPKeys();
+
+ void KDF(uint8_t* key, uint32_t keyLength, uint8_t* label, int32_t labelLength,
+ uint8_t* context, int32_t contextLength, int32_t L, uint8_t* output);
+
+ void generateKeysInitiator(ZrtpPacketDHPart *dhPart, ZIDRecord& zidRec);
+
+ void generateKeysResponder(ZrtpPacketDHPart *dhPart, ZIDRecord& zidRec);
+
+ void generateKeysMultiStream();
+
+ void computePBXSecret();
+
+ void setNegotiatedHash(AlgorithmEnum* hash);
+
+ /*
+ * The following methods are helper functions for ZrtpStateClass.
+ * ZrtpStateClass calls them to prepare packets, send data, report
+ * problems, etc.
+ */
+ /**
+ * Send a ZRTP packet.
+ *
+ * The state engines calls this method to send a packet via the RTP
+ * stack.
+ *
+ * @param packet
+ * Points to the ZRTP packet.
+ * @return
+ * zero if sending failed, one if packet was send
+ */
+ int32_t sendPacketZRTP(ZrtpPacketBase *packet);
+
+ /**
+ * Activate a Timer using the host callback.
+ *
+ * @param tm
+ * The time in milliseconds.
+ * @return
+ * zero if activation failed, one if timer was activated
+ */
+ int32_t activateTimer(int32_t tm);
+
+ /**
+ * Cancel the active Timer using the host callback.
+ *
+ * @return
+ * zero if activation failed, one if timer was activated
+ */
+ int32_t cancelTimer();
+
+ /**
+ * Prepare a Hello packet.
+ *
+ * Just take the preinitialized Hello packet and return it. No
+ * further processing required.
+ *
+ * @return
+ * A pointer to the initialized Hello packet.
+ */
+ ZrtpPacketHello* prepareHello();
+
+ /**
+ * Prepare a HelloAck packet.
+ *
+ * Just take the preinitialized HelloAck packet and return it. No
+ * further processing required.
+ *
+ * @return
+ * A pointer to the initialized HelloAck packet.
+ */
+ ZrtpPacketHelloAck* prepareHelloAck();
+
+ /**
+ * Prepare a Commit packet.
+ *
+ * We have received a Hello packet from our peer. Check the offers
+ * it makes to us and select the most appropriate. Using the
+ * selected values prepare a Commit packet and return it to protocol
+ * state engine.
+ *
+ * @param hello
+ * Points to the received Hello packet
+ * @param errMsg
+ * Points to an integer that can hold a ZRTP error code.
+ * @return
+ * A pointer to the prepared Commit packet
+ */
+ ZrtpPacketCommit* prepareCommit(ZrtpPacketHello *hello, uint32_t* errMsg);
+
+ /**
+ * Prepare a Commit packet for Multi Stream mode.
+ *
+ * Using the selected values prepare a Commit packet and return it to protocol
+ * state engine.
+ *
+ * @param hello
+ * Points to the received Hello packet
+ * @return
+ * A pointer to the prepared Commit packet for multi stream mode
+ */
+ ZrtpPacketCommit* prepareCommitMultiStream(ZrtpPacketHello *hello);
+
+ /**
+ * Prepare the DHPart1 packet.
+ *
+ * This method prepares a DHPart1 packet. The input to the method is always
+ * a Commit packet received from the peer. Also we a in the role of the
+ * Responder.
+ *
+ * When we receive a Commit packet we get the selected ciphers, hashes, etc
+ * and cross-check if this is ok. Then we need to initialize a set of DH
+ * keys according to the selected cipher. Using this data we prepare our DHPart1
+ * packet.
+ */
+ ZrtpPacketDHPart* prepareDHPart1(ZrtpPacketCommit *commit, uint32_t* errMsg);
+
+ /**
+ * Prepare the DHPart2 packet.
+ *
+ * This method prepares a DHPart2 packet. The input to the method is always
+ * a DHPart1 packet received from the peer. Our peer sends the DH1Part as
+ * response to our Commit packet. Thus we are in the role of the
+ * Initiator.
+ *
+ */
+ ZrtpPacketDHPart* prepareDHPart2(ZrtpPacketDHPart* dhPart1, uint32_t* errMsg);
+
+ /**
+ * Prepare the Confirm1 packet.
+ *
+ * This method prepare the Confirm1 packet. The input to this method is the
+ * DHPart2 packect received from our peer. The peer sends the DHPart2 packet
+ * as response of our DHPart1. Here we are in the role of the Responder
+ *
+ */
+ ZrtpPacketConfirm* prepareConfirm1(ZrtpPacketDHPart* dhPart2, uint32_t* errMsg);
+
+ /**
+ * Prepare the Confirm1 packet in multi stream mode.
+ *
+ * This method prepares the Confirm1 packet. The state engine call this method
+ * if multi stream mode is selected and a Commit packet was received. The input to
+ * this method is the Commit.
+ * Here we are in the role of the Responder
+ *
+ */
+ ZrtpPacketConfirm* prepareConfirm1MultiStream(ZrtpPacketCommit* commit, uint32_t* errMsg);
+
+ /**
+ * Prepare the Confirm2 packet.
+ *
+ * This method prepare the Confirm2 packet. The input to this method is the
+ * Confirm1 packet received from our peer. The peer sends the Confirm1 packet
+ * as response of our DHPart2. Here we are in the role of the Initiator
+ */
+ ZrtpPacketConfirm* prepareConfirm2(ZrtpPacketConfirm* confirm1, uint32_t* errMsg);
+
+ /**
+ * Prepare the Confirm2 packet in multi stream mode.
+ *
+ * This method prepares the Confirm2 packet. The state engine call this method if
+ * multi stream mode is active and in state CommitSent. The input to this method is
+ * the Confirm1 packet received from our peer. The peer sends the Confirm1 packet
+ * as response of our Commit packet in multi stream mode.
+ * Here we are in the role of the Initiator
+ */
+ ZrtpPacketConfirm* prepareConfirm2MultiStream(ZrtpPacketConfirm* confirm1, uint32_t* errMsg);
+
+ /**
+ * Prepare the Conf2Ack packet.
+ *
+ * This method prepare the Conf2Ack packet. The input to this method is the
+ * Confirm2 packet received from our peer. The peer sends the Confirm2 packet
+ * as response of our Confirm1. Here we are in the role of the Initiator
+ */
+ ZrtpPacketConf2Ack* prepareConf2Ack(ZrtpPacketConfirm* confirm2, uint32_t* errMsg);
+
+ /**
+ * Prepare the ErrorAck packet.
+ *
+ * This method prepares the ErrorAck packet. The input to this method is the
+ * Error packet received from the peer.
+ */
+ ZrtpPacketErrorAck* prepareErrorAck(ZrtpPacketError* epkt);
+
+ /**
+ * Prepare the Error packet.
+ *
+ * This method prepares the Error packet. The input to this method is the
+ * error code to be included into the message.
+ */
+ ZrtpPacketError* prepareError(uint32_t errMsg);
+
+ /**
+ * Prepare a ClearAck packet.
+ *
+ * This method checks if the GoClear message is valid. If yes then switch
+ * off SRTP processing, stop sending of RTP packets (pause transmit) and
+ * inform the user about the fact. Only if user confirms the GoClear message
+ * normal RTP processing is resumed.
+ *
+ * @return
+ * NULL if GoClear could not be authenticated, a ClearAck packet
+ * otherwise.
+ */
+ ZrtpPacketClearAck* prepareClearAck(ZrtpPacketGoClear* gpkt);
+
+ /**
+ * Prepare the ErrorAck packet.
+ *
+ * This method prepares the ErrorAck packet. The input to this method is the
+ * Error packet received from the peer.
+ */
+ ZrtpPacketPingAck* preparePingAck(ZrtpPacketPing* ppkt);
+
+ /**
+ * Prepare the RelayAck packet.
+ *
+ * This method prepares the RelayAck packet. The input to this method is the
+ * SASrelay packet received from the peer.
+ */
+ ZrtpPacketRelayAck* prepareRelayAck(ZrtpPacketSASrelay* srly, uint32_t* errMsg);
+
+ /**
+ * Prepare a GoClearAck packet w/o HMAC
+ *
+ * Prepare a GoCLear packet without a HMAC but with a short error message.
+ * This type of GoClear is used if something went wrong during the ZRTP
+ * negotiation phase.
+ *
+ * @return
+ * A goClear packet without HMAC
+ */
+ ZrtpPacketGoClear* prepareGoClear(uint32_t errMsg = 0);
+
+ /**
+ * Compare the hvi values.
+ *
+ * Compare a received Commit packet with our Commit packet and returns
+ * which Commit packt is "more important". See chapter 5.2 to get further
+ * information how to compare Commit packets.
+ *
+ * @param commit
+ * Pointer to the peer's commit packet we just received.
+ * @return
+ * <0 if our Commit packet is "less important"
+ * >0 if our Commit is "more important"
+ * 0 shouldn't happen because we compare crypto hashes
+ */
+ int32_t compareCommit(ZrtpPacketCommit *commit);
+
+ /**
+ * Verify the H2 hash image.
+ *
+ * Verifies the H2 hash contained in a received commit message.
+ * This functions just verifies H2 but does not store it.
+ *
+ * @param commit
+ * Pointer to the peer's commit packet we just received.
+ * @return
+ * true if H2 is ok and verified
+ * false if H2 could not be verified
+ */
+ bool verifyH2(ZrtpPacketCommit *commit);
+
+ /**
+ * Send information messages to the hosting environment.
+ *
+ * The ZRTP implementation uses this method to send information messages
+ * to the host. Along with the message ZRTP provides a severity indicator
+ * that defines: Info, Warning, Error, Alert. Refer to the MessageSeverity
+ * enum in the ZrtpCallback class.
+ *
+ * @param severity
+ * This defines the message's severity
+ * @param subCode
+ * The subcode identifying the reason.
+ * @see ZrtpCodes#MessageSeverity
+ */
+ void sendInfo(GnuZrtpCodes::MessageSeverity severity, int32_t subCode);
+
+ /**
+ * ZRTP state engine calls this if the negotiation failed.
+ *
+ * ZRTP calls this method in case ZRTP negotiation failed. The parameters
+ * show the severity as well as some explanatory text.
+ *
+ * @param severity
+ * This defines the message's severity
+ * @param subCode
+ * The subcode identifying the reason.
+ * @see ZrtpCodes#MessageSeverity
+ */
+ void zrtpNegotiationFailed(GnuZrtpCodes::MessageSeverity severity, int32_t subCode);
+
+ /**
+ * ZRTP state engine calls this method if the other side does not support ZRTP.
+ *
+ * If the other side does not answer the ZRTP <em>Hello</em> packets then
+ * ZRTP calls this method,
+ *
+ */
+ void zrtpNotSuppOther();
+
+ /**
+ * Signal SRTP secrets are ready.
+ *
+ * This method calls a callback method to inform the host that the SRTP
+ * secrets are ready.
+ *
+ * @param part
+ * Defines for which part (sender or receiver) to switch on security
+ * @return
+ * Returns false if something went wrong during initialization of SRTP
+ * context. Propagate error back to state engine.
+ */
+ bool srtpSecretsReady(EnableSecurity part);
+
+ /**
+ * Switch off SRTP secrets.
+ *
+ * This method calls a callback method to inform the host that the SRTP
+ * secrets shall be cleared.
+ *
+ * @param part
+ * Defines for which part (sender or receiver) to clear
+ */
+ void srtpSecretsOff(EnableSecurity part);
+
+ /**
+ * ZRTP state engine calls these methods to enter or leave its
+ * synchronization mutex.
+ */
+ void synchEnter();
+
+ void synchLeave();
+
+ /**
+ * Helper function to store ZRTP message data in a temporary buffer
+ *
+ * This functions first clears the temporary buffer, then stores
+ * the packet's data to it. We use this to check the packet's HMAC
+ * after we received the HMAC key in to following packet.
+ *
+ * @param data
+ * Pointer to the packet's ZRTP message
+ */
+ void storeMsgTemp(ZrtpPacketBase* pkt);
+
+ /**
+ * Helper function to check a ZRTP message HMAC
+ *
+ * This function gets a HMAC key and uses it to compute a HMAC
+ * with this key and the stored data of a previous received ZRTP
+ * message. It compares the computed HMAC and the HMAC stored in
+ * the received message and returns the result.
+ *
+ * @param key
+ * Pointer to the HMAC key.
+ * @return
+ * Returns true if the computed HMAC and the stored HMAC match,
+ * false otherwise.
+ */
+ bool checkMsgHmac(uint8_t* key);
+
+ /**
+ * Set the client ID for ZRTP Hello message.
+ *
+ * The user of ZRTP must set its id to identify itself in the
+ * ZRTP HELLO message. The maximum length is 16 characters. Shorter
+ * id string are allowed, they will be filled with blanks. A longer id
+ * is truncated to 16 characters.
+ *
+ * The identifier is set in the Hello packet of ZRTP. Thus only after
+ * setting the identifier ZRTP can compute the HMAC and the final
+ * helloHash.
+ *
+ * @param id
+ * The client's id
+ */
+ void setClientId(std::string id);
+};
+
+/**
+ * @}
+ */
+#endif // ZRTP
+
diff --git a/src/libzrtpcpp/ZrtpCWrapper.h b/src/libzrtpcpp/ZrtpCWrapper.h
new file mode 100644
index 0000000..0126545
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpCWrapper.h
@@ -0,0 +1,1339 @@
+/*
+ This file defines the GNU ZRTP 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 ZRTPCWRAPPER_H
+#define ZRTPCWRAPPER_H
+
+/**
+ *
+ * @file ZrtpCWrapper.h
+ * @brief The GNU ZRTP C-to-C++ wrapper.
+ *
+ * To avoid any include of C++ header files some structure, defines, and
+ * enumerations are repeated in this file. Refer to the inline comments if
+ * you modify the file.
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ *
+ * @see ZRtp
+ */
+
+#include <stdint.h>
+
+/**
+ * Defines to specify the role a ZRTP peer has.
+ *
+ * According to the ZRTP specification the role determines which keys to
+ * use to encrypt or decrypt SRTP data.
+ *
+ * <ul>
+ * <li> The Initiator encrypts SRTP data using the <em>keyInitiator</em> and the
+ * <em>saltInitiator</em> data, the Responder uses these data to decrypt.
+ * </li>
+ * <li> The Responder encrypts SRTP data using the <em>keyResponder</em> and the
+ * <em>saltResponder</em> data, the Initiator uses these data to decrypt.
+ * </li>
+ * </ul>
+ */
+/*
+ * Keep the following defines in sync with Role enumeration in ZrtpCallback.h
+ */
+#define Responder 1 /*!< This client is in ZRTP Responder mode */
+#define Initiator 2 /*!< This client is in ZRTP Initiator mode */
+
+#define CRC_SIZE 4 /*!< Size of CRC code of a ZRTP packet */
+#define ZRTP_MAGIC 0x5a525450 /*!< The magic code that identifies a ZRTP packet */
+#define MAX_ZRTP_SIZE 3072 /*!< The biggest ZRTP packet ever possible */
+
+/*
+ * IMPORTANT: keep the following enums in synch with ZrtpCodes. We copy them here
+ * to avoid any C++ header includes and defines. The protocol states are located
+ * ZrtpStateClass.h .
+ */
+/**
+ * This enum defines the information message severity.
+ *
+ * The ZRTP implementation issues information messages to inform the user
+ * about ongoing processing, unusual behavior, or alerts in case of severe
+ * problems. Each main severity code a number of sub-codes exist that
+ * specify the exact nature of the problem.
+ *
+ * An application gets message severity codes and the associated sub-codes
+ * via the ZrtpUserCallback#showMessage method.
+ *
+ * The severity levels and their meaning are:
+ *
+ * <dl>
+ * <dt>Info</dt> <dd>keeps the user informed about ongoing processing and
+ * security setup. The enumeration InfoCodes defines the subcodes.
+ * </dd>
+ * <dt>Warning</dt> <dd>is an information about some security issues, e.g. if
+ * an AES 256 encryption is request but only DH 3072 as public key scheme
+ * is supported. ZRTP will establish a secure session (SRTP). The
+ * enumeration WarningCodes defines the sub-codes.
+ * </dd>
+ * <dt>Severe</dt> <dd>is used if an error occured during ZRTP protocol usage.
+ * In case of <em>Severe</em> ZRTP will <b>not</b> establish a secure session.
+ * The enumeration SevereCodes defines the sub-codes.
+ * </dd>
+ * <dt>Zrtp</dt> <dd>shows a ZRTP security problem. Refer to the enumeration
+ * ZrtpErrorCodes for sub-codes. GNU ZRTP of course will <b>not</b>
+ * establish a secure session.
+ * </dd>
+ * </dl>
+ *
+ */
+enum zrtp_MessageSeverity {
+ zrtp_Info = 1, /*!< Just an info message */
+ zrtp_Warning, /*!< A Warning message - security can be established */
+ zrtp_Severe, /*!< Severe error, security will not be established */
+ zrtp_ZrtpError /*!< ZRTP error, security will not be established */
+};
+
+/**
+ * Sub-codes for Info
+ */
+enum zrtp_InfoCodes {
+ zrtp_InfoHelloReceived = 1, /*!< Hello received, preparing a Commit */
+ zrtp_InfoCommitDHGenerated, /*!< Commit: Generated a public DH key */
+ zrtp_InfoRespCommitReceived, /*!< Responder: Commit received, preparing DHPart1 */
+ zrtp_InfoDH1DHGenerated, /*!< DH1Part: Generated a public DH key */
+ zrtp_InfoInitDH1Received, /*!< Initiator: DHPart1 received, preparing DHPart2 */
+ zrtp_InfoRespDH2Received, /*!< Responder: DHPart2 received, preparing Confirm1 */
+ zrtp_InfoInitConf1Received, /*!< Initiator: Confirm1 received, preparing Confirm2 */
+ zrtp_InfoRespConf2Received, /*!< Responder: Confirm2 received, preparing Conf2Ack */
+ zrtp_InfoRSMatchFound, /*!< At least one retained secrets matches - security OK */
+ zrtp_InfoSecureStateOn, /*!< Entered secure state */
+ zrtp_InfoSecureStateOff /*!< No more security for this session */
+};
+
+/**
+ * Sub-codes for Warning
+ */
+enum zrtp_WarningCodes {
+ zrtp_WarningDHAESmismatch = 1, /*!< Commit contains an AES256 cipher but does not offer a Diffie-Helman 4096 */
+ zrtp_WarningGoClearReceived, /*!< Received a GoClear message */
+ zrtp_WarningDHShort, /*!< Hello offers an AES256 cipher but does not offer a Diffie-Helman 4096 */
+ zrtp_WarningNoRSMatch, /*!< No retained shared secrets available - must verify SAS */
+ zrtp_WarningCRCmismatch, /*!< Internal ZRTP packet checksum mismatch - packet dropped */
+ zrtp_WarningSRTPauthError, /*!< Dropping packet because SRTP authentication failed! */
+ zrtp_WarningSRTPreplayError, /*!< Dropping packet because SRTP replay check failed! */
+ zrtp_WarningNoExpectedRSMatch /*!< Valid retained shared secrets availabe but no matches found - must verify SAS */
+};
+
+/**
+ * Sub-codes for Severe
+ */
+enum zrtp_SevereCodes {
+ zrtp_SevereHelloHMACFailed = 1, /*!< Hash HMAC check of Hello failed! */
+ zrtp_SevereCommitHMACFailed, /*!< Hash HMAC check of Commit failed! */
+ zrtp_SevereDH1HMACFailed, /*!< Hash HMAC check of DHPart1 failed! */
+ zrtp_SevereDH2HMACFailed, /*!< Hash HMAC check of DHPart2 failed! */
+ zrtp_SevereCannotSend, /*!< Cannot send data - connection or peer down? */
+ zrtp_SevereProtocolError, /*!< Internal protocol error occured! */
+ zrtp_SevereNoTimer, /*!< Cannot start a timer - internal resources exhausted? */
+ zrtp_SevereTooMuchRetries /*!< Too much retries during ZRTP negotiation - connection or peer down? */
+};
+
+/**
+ * Error codes according to the ZRTP specification chapter 6.9
+ *
+ * GNU ZRTP uses these error codes in two ways: to fill the appropriate
+ * field ing the ZRTP Error packet and as sub-code in
+ * ZrtpUserCallback#showMessage(). GNU ZRTP uses thes error codes also
+ * to report received Error packts, in this case the sub-codes are their
+ * negative values.
+ *
+ * The enumeration member comments are copied from the ZRTP specification.
+ */
+enum zrtp_ZrtpErrorCodes {
+ zrtp_MalformedPacket = 0x10, /*!< Malformed packet (CRC OK, but wrong structure) */
+ zrtp_CriticalSWError = 0x20, /*!< Critical software error */
+ zrtp_UnsuppZRTPVersion = 0x30, /*!< Unsupported ZRTP version */
+ zrtp_HelloCompMismatch = 0x40, /*!< Hello components mismatch */
+ zrtp_UnsuppHashType = 0x51, /*!< Hash type not supported */
+ zrtp_UnsuppCiphertype = 0x52, /*!< Cipher type not supported */
+ zrtp_UnsuppPKExchange = 0x53, /*!< Public key exchange not supported */
+ zrtp_UnsuppSRTPAuthTag = 0x54, /*!< SRTP auth. tag not supported */
+ zrtp_UnsuppSASScheme = 0x55, /*!< SAS scheme not supported */
+ zrtp_NoSharedSecret = 0x56, /*!< No shared secret available, DH mode required */
+ zrtp_DHErrorWrongPV = 0x61, /*!< DH Error: bad pvi or pvr ( == 1, 0, or p-1) */
+ zrtp_DHErrorWrongHVI = 0x62, /*!< DH Error: hvi != hashed data */
+ zrtp_SASuntrustedMiTM = 0x63, /*!< Received relayed SAS from untrusted MiTM */
+ zrtp_ConfirmHMACWrong = 0x70, /*!< Auth. Error: Bad Confirm pkt HMAC */
+ zrtp_NonceReused = 0x80, /*!< Nonce reuse */
+ zrtp_EqualZIDHello = 0x90, /*!< Equal ZIDs in Hello */
+ zrtp_GoCleatNotAllowed = 0x100, /*!< GoClear packet received, but not allowed */
+ zrtp_IgnorePacket = 0x7fffffff /*!< Internal state, not reported */
+};
+
+/**
+ * Information codes for the Enrollment user callbacks.
+ */
+enum zrtp_InfoEnrollment {
+ zrtp_EnrollmentRequest, //!< Aks user to confirm or deny an Enrollemnt request
+ zrtp_EnrollmentCanceled, //!< User did not confirm the PBX enrollement
+ zrtp_EnrollmentFailed, //!< Enrollment process failed, no PBX secret available
+ zrtp_EnrollmentOk //!< Enrollment process for this PBX was ok
+};
+
+/* The ZRTP protocol states */
+enum zrtpStates {
+ Initial, /*!< Initial state after starting the state engine */
+ Detect, /*!< State sending Hello, try to detect answer message */
+ AckDetected, /*!< HelloAck received */
+ AckSent, /*!< HelloAck sent after Hello received */
+ WaitCommit, /*!< Wait for a Commit message */
+ CommitSent, /*!< Commit message sent */
+ WaitDHPart2, /*!< Wait for a DHPart2 message */
+ WaitConfirm1, /*!< Wait for a Confirm1 message */
+ WaitConfirm2, /*!< Wait for a confirm2 message */
+ WaitConfAck, /*!< Wait for Conf2Ack */
+ WaitClearAck, /*!< Wait for clearAck - not used */
+ SecureState, /*!< This is the secure state - SRTP active */
+ WaitErrorAck, /*!< Wait for ErrorAck message */
+ numberOfStates /*!< Gives total number of protocol states */
+};
+
+/*! The algorihms that we support in SRTP and that ZRTP can negotiate. */
+typedef enum {
+ zrtp_Aes = 1, /*!< Use AES as symmetrical cipher algorithm */
+ zrtp_TwoFish, /*!< Use TwoFish as symmetrical cipher algorithm */
+ zrtp_Sha1, /*!< Use Sha1 as authentication algorithm */
+ zrtp_Skein /*!< Use Skein as authentication algorithm */
+} zrtp_SrtpAlgorithms;
+
+/**
+ * This structure contains pointers to the SRTP secrets and the role info.
+ *
+ * About the role and what the meaning of the role is refer to the
+ * of the enum Role. The pointers to the secrets are valid as long as
+ * the ZRtp object is active. To use these data after the ZRtp object's
+ * lifetime you may copy the data into a save place.
+ */
+typedef struct c_srtpSecrets
+{
+ zrtp_SrtpAlgorithms symEncAlgorithm;/*!< symmetrical cipher algorithm */
+ const uint8_t* keyInitiator; /*!< Initiator's key */
+ int32_t initKeyLen; /*!< Initiator's key length */
+ const uint8_t* saltInitiator; /*!< Initiator's salt */
+ int32_t initSaltLen; /*!< Initiator's salt length */
+ const uint8_t* keyResponder; /*!< Responder's key */
+ int32_t respKeyLen; /*!< Responder's key length */
+ const uint8_t* saltResponder; /*!< Responder's salt */
+ int32_t respSaltLen; /*!< Responder's salt length */
+ zrtp_SrtpAlgorithms authAlgorithm; /*!< SRTP authentication algorithm */
+ int32_t srtpAuthTagLen; /*!< SRTP authentication length */
+ char* sas; /*!< The SAS string */
+ int32_t role; /*!< ZRTP role of this client */
+} C_SrtpSecret_t;
+
+/*
+ * Keep the following defines in sync with enum EnableSecurity in ZrtpCallback.h
+ */
+#define ForReceiver 1 /*!< Enable security for SRTP receiver */
+#define ForSender 2 /*!< Enable security for SRTP sender */
+
+#ifdef __cplusplus
+#pragma GCC visibility push(default)
+extern "C"
+{
+#endif
+
+ typedef struct ZRtp ZRtp;
+ typedef struct ZrtpCallbackWrapper ZrtpCallbackWrapper;
+ typedef struct ZrtpConfigure ZrtpConfigure;
+
+
+ typedef struct zrtpContext
+ {
+ ZRtp* zrtpEngine; /*!< Holds the real ZRTP engine */
+ ZrtpCallbackWrapper* zrtpCallback; /*!< Help class Callback wrapper */
+ ZrtpConfigure* configure; /*!< Optional configuration data */
+ void* userData; /*!< User data, set by application */
+ } ZrtpContext;
+
+ /**
+ * This structure defines the callback functions required by GNU ZRTP.
+ *
+ * The RTP stack specific part must implement the callback methods.
+ * The generic part of GNU ZRTP uses these mehtods
+ * to communicate with the specific part, for example to send data
+ * via the RTP/SRTP stack, to set timers and cancel timer and so on.
+ *
+ * The generiy part of GNU ZRTP needs only a few callback methods to
+ * be implemented by the specific part.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+ /**
+ * The following methods define the GNU ZRTP callback interface.
+ * For detailed documentation refer to file ZrtpCallback.h, each C
+ * method has "zrtp_" prepended to the C++ name.
+ *
+ * @see ZrtpCallback
+ */
+ typedef struct zrtp_Callbacks
+ {
+ /**
+ * Send a ZRTP packet via RTP.
+ *
+ * ZRTP calls this method to send a ZRTP packet via the RTP session.
+ * The ZRTP packet will have to be created using the provided ZRTP message.
+ *
+ * @param ctx
+ * Pointer to the opaque ZrtpContext structure.
+ * @param data
+ * Points to ZRTP message to send.
+ * @param length
+ * The length in bytes of the data
+ * @return
+ * zero if sending failed, one if packet was sent
+ */
+ int32_t (*zrtp_sendDataZRTP) (ZrtpContext* ctx, const uint8_t* data, int32_t length ) ;
+
+ /**
+ * Activate timer.
+ *
+ * @param ctx
+ * Pointer to the opaque ZrtpContext structure.
+ * @param time
+ * The time in ms for the timer
+ * @return
+ * zero if activation failed, one if timer was activated
+ */
+ int32_t (*zrtp_activateTimer) (ZrtpContext* ctx, int32_t time ) ;
+
+ /**
+ * Cancel the active timer.
+ *
+ * @param ctx
+ * Pointer to the opaque ZrtpContext structure.
+ * @return
+ * zero if cancel action failed, one if timer was canceled
+ */
+ int32_t (*zrtp_cancelTimer)(ZrtpContext* ctx) ;
+
+ /**
+ * Send information messages to the hosting environment.
+ *
+ * The ZRTP implementation uses this method to send information
+ * messages to the host. Along with the message ZRTP provides a
+ * severity indicator that defines: Info, Warning, Error,
+ * Alert. Refer to the <code>MessageSeverity</code> enum above.
+ *
+ * @param ctx
+ * Pointer to the opaque ZrtpContext structure.
+ * @param severity
+ * This defines the message's severity
+ * @param subCode
+ * The subcode identifying the reason.
+ * @see ZrtpCodes#MessageSeverity
+ */
+ void (*zrtp_sendInfo) (ZrtpContext* ctx, int32_t severity, int32_t subCode ) ;
+
+ /**
+ * SRTP crypto data ready for the sender or receiver.
+ *
+ * The ZRTP implementation calls this method right after all SRTP
+ * secrets are computed and ready to be used. The parameter points
+ * to a structure that contains pointers to the SRTP secrets and a
+ * <code>enum Role</code>. The called method (the implementation
+ * of this abstract method) must either copy the pointers to the SRTP
+ * data or the SRTP data itself to a save place. The SrtpSecret_t
+ * structure is destroyed after the callback method returns to the
+ * ZRTP implementation.
+ *
+ * The SRTP data themselves are obtained in the ZRtp object and are
+ * valid as long as the ZRtp object is active. TheZRtp's
+ * destructor clears the secrets. Thus the called method needs to
+ * save the pointers only, ZRtp takes care of the data.
+ *
+ * The implementing class may enable SRTP processing in this
+ * method or delay it to srtpSecertsOn().
+ *
+ * @param ctx
+ * Pointer to the opaque ZrtpContext structure.
+ * @param secrets A pointer to a SrtpSecret_t structure that
+ * contains all necessary data.
+ *
+ * @param part for which part (Sender or Receiver) this data is
+ * valid.
+ *
+ * @return Returns false if something went wrong during
+ * initialization of SRTP context, for example memory shortage.
+ */
+ int32_t (*zrtp_srtpSecretsReady) (ZrtpContext* ctx, C_SrtpSecret_t* secrets, int32_t part ) ;
+
+ /**
+ * Switch off the security for the defined part.
+ *
+ * @param ctx
+ * Pointer to the opaque ZrtpContext structure.
+ * @param part Defines for which part (sender or receiver) to
+ * switch on security
+ */
+ void (*zrtp_srtpSecretsOff) (ZrtpContext* ctx, int32_t part ) ;
+
+ /**
+ * Switch on the security.
+ *
+ * ZRTP calls this method after it has computed the SAS and check
+ * if it is verified or not. In addition ZRTP provides information
+ * about the cipher algorithm and key length for the SRTP session.
+ *
+ * This method must enable SRTP processing if it was not enabled
+ * during sertSecretsReady().
+ *
+ * @param ctx
+ * Pointer to the opaque ZrtpContext structure.
+ * @param c The name of the used cipher algorithm and mode, or
+ * NULL
+ *
+ * @param s The SAS string
+ *
+ * @param verified if <code>verified</code> is true then SAS was
+ * verified by both parties during a previous call.
+ */
+ void (*zrtp_rtpSecretsOn) (ZrtpContext* ctx, char* c, char* s, int32_t verified ) ;
+
+ /**
+ * This method handles GoClear requests.
+ *
+ * According to the ZRTP specification the user must be informed about
+ * a GoClear request because the ZRTP implementation switches off security
+ * if it could authenticate the GoClear packet.
+ *
+ * <b>Note:</b> GoClear is not yet implemented in GNU ZRTP.
+ *
+ * @param ctx
+ * Pointer to the opaque ZrtpContext structure.
+ */
+ void (*zrtp_handleGoClear)(ZrtpContext* ctx) ;
+
+ /**
+ * Handle ZRTP negotiation failed.
+ *
+ * ZRTP calls this method in case ZRTP negotiation failed. The
+ * parameters show the severity as well as the reason.
+ *
+ * @param ctx
+ * Pointer to the opaque ZrtpContext structure.
+ * @param severity
+ * This defines the message's severity
+ * @param subCode
+ * The subcode identifying the reason.
+ * @see ZrtpCodes#MessageSeverity
+ */
+ void (*zrtp_zrtpNegotiationFailed) (ZrtpContext* ctx, int32_t severity, int32_t subCode ) ;
+
+ /**
+ * ZRTP calls this method if the other side does not support ZRTP.
+ *
+ * @param ctx
+ * Pointer to the opaque ZrtpContext structure.
+ * If the other side does not answer the ZRTP <em>Hello</em> packets then
+ * ZRTP calls this method,
+ *
+ */
+ void (*zrtp_zrtpNotSuppOther)(ZrtpContext* ctx) ;
+
+ /**
+ * Enter synchronization mutex.
+ *
+ * GNU ZRTP requires one mutex to synchronize its
+ * processing. Because mutex implementations depend on the
+ * underlying infrastructure, for example operating system or
+ * thread implementation, GNU ZRTP delegates mutex handling to the
+ * specific part of its implementation.
+ *
+ * @param ctx
+ * Pointer to the opaque ZrtpContext structure.
+ */
+ void (*zrtp_synchEnter)(ZrtpContext* ctx) ;
+
+ /**
+ * Leave synchronization mutex.
+ *
+ * @param ctx
+ * Pointer to the opaque ZrtpContext structure.
+ */
+ void (*zrtp_synchLeave)(ZrtpContext* ctx) ;
+
+ /**
+ * Inform about a PBX enrollment request.
+ *
+ * Please refer to chapter 8.3 ff to get more details about PBX
+ * enrollment and SAS relay.
+ *
+ * <b>Note:</b> PBX enrollement is not yet fully supported by GNU
+ * ZRTP.
+ *
+ * @param ctx
+ * Pointer to the opaque ZrtpContext structure.
+ * @param info Give some information to the user about the PBX
+ * requesting an enrollment.
+ */
+ void (*zrtp_zrtpAskEnrollment) (ZrtpContext* ctx, int32_t info) ;
+
+ /**
+ * Inform about PBX enrollment result.
+ *
+ * Informs the use about the acceptance or denial of an PBX enrollment
+ * request
+ *
+ * <b>Note:</b> PBX enrollement is not yet fully supported by GNU
+ * ZRTP.
+ *
+ * @param ctx
+ * Pointer to the opaque ZrtpContext structure.
+ * @param info Give some information to the user about the result
+ * of an enrollment.
+ */
+ void (*zrtp_zrtpInformEnrollment) (ZrtpContext* ctx, int32_t info ) ;
+
+ /**
+ * Request a SAS signature.
+ *
+ * After ZRTP was able to compute the Short Authentication String
+ * (SAS) it calls this method. The client may now use an
+ * approriate method to sign the SAS. The client may use
+ * ZrtpQueue#setSignatureData() to store the signature data and
+ * enable signature transmission to the other peer. Refer to
+ * chapter 8.2 of ZRTP specification.
+ *
+ * <b>Note:</b> SAS signing is not yet fully supported by GNU
+ * ZRTP.
+ *
+ * @param ctx
+ * Pointer to the opaque ZrtpContext structure.
+ * @param sas
+ * Pointer to the 32 byte SAS hash to sign.
+ *
+ */
+ void (*zrtp_signSAS)(ZrtpContext* ctx, uint8_t* sas) ;
+
+ /**
+ * ZRTPQueue calls this method to request a SAS signature check.
+ *
+ * After ZRTP received a SAS signature in one of the Confirm packets it
+ * call this method. The client may use <code>getSignatureLength()</code>
+ * and <code>getSignatureData()</code>of ZrtpQueue to get the signature
+ * data and perform the signature check. Refer to chapter 8.2 of ZRTP
+ * specification.
+ *
+ * If the signature check fails the client may return false to ZRTP. In
+ * this case ZRTP signals an error to the other peer and terminates
+ * the ZRTP handshake.
+ *
+ * <b>Note:</b> SAS signing is not yet fully supported by GNU
+ * ZRTP.
+ *
+ * @param ctx
+ * Pointer to the opaque ZrtpContext structure.
+ * @param sas
+ * Pointer to the 32 byte SAS hash that was signed by the other peer.
+ * @return
+ * true if the signature was ok, false otherwise.
+ *
+ */
+ int32_t (*zrtp_checkSASSignature) (ZrtpContext* ctx, uint8_t* sas ) ;
+ } zrtp_Callbacks;
+
+ /**
+ * Create the GNU ZRTP C wrapper.
+ *
+ * This wrapper implements the C interface to the C++ based GNU ZRTP.
+ * @returns
+ * Pointer to the ZrtpContext
+ */
+ ZrtpContext* zrtp_CreateWrapper();
+
+ /**
+ * Initialize the ZRTP protocol engine.
+ *
+ * This method initialized the GNU ZRTP protocol engine. An application
+ * calls this method to actually create the ZRTP protocol engine and
+ * initialize its configuration data. This method does not start the
+ * protocol engine.
+ *
+ * If an application requires a specific algorithm configuration then it
+ * must set the algorithm configuration data before it initializes the
+ * ZRTP protocol engine.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param cb
+ * The callback structure that holds the addresses of the callback
+ * methods.
+ * @param id
+ * A C string that holds the ZRTP client id, only the first 16 chars
+ * are used.
+ * @param zidFilename
+ * The name of the ZID file. This file holds some parameters and
+ * other data like additional shared secrets.
+ * @param userData
+ * A pointer to user data. The wrapper just stores this pointer in
+ * the ZrtpContext and the application may use it for its purposes.
+ * @param mitmMode
+ * A trusted Mitm (PBX) must set this to true. The ZRTP engine sets
+ * the M Flag in the Hello packet to announce a trusted MitM.
+ * @returns
+ * Pointer to the ZrtpContext
+ *
+ * @see zrtp_InitializeConfig
+ */
+ void zrtp_initializeZrtpEngine(ZrtpContext* zrtpContext,
+ zrtp_Callbacks *cb,
+ const char* id,
+ const char* zidFilename,
+ void* userData,
+ int32_t mitmMode);
+
+ /**
+ * Destroy the ZRTP wrapper and its underlying objects.
+ */
+ void zrtp_DestroyWrapper (ZrtpContext* zrtpContext);
+
+ /**
+ * Computes the ZRTP checksum over a received ZRTP packet buffer and
+ * compares the result with received checksum.
+ *
+ * @param buffer
+ * Pointer to ZRTP packet buffer
+ * @param length
+ * Length of the packet buffer excluding received CRC data
+ * @param crc
+ * The received CRC data.
+ * @returns
+ * True if CRC matches, false otherwise.
+ */
+ int32_t zrtp_CheckCksum(uint8_t* buffer, uint16_t length, uint32_t crc);
+
+ /**
+ * Computes the ZRTP checksum over a newly created ZRTP packet buffer.
+ *
+ * @param buffer
+ * Pointer to the created ZRTP packet buffer
+ * @param length
+ * Length of the packet buffer
+ * @returns
+ * The computed CRC.
+ */
+ uint32_t zrtp_GenerateCksum(uint8_t* buffer, uint16_t length);
+
+ /**
+ * Prepares the ZRTP checksum for appending to ZRTP packet.
+ * @param crc
+ * The computed CRC data.
+ * @returns
+ * Prepared CRC data in host order
+ */
+ uint32_t zrtp_EndCksum(uint32_t crc);
+
+ /**
+ * Kick off the ZRTP protocol engine.
+ *
+ * This method calls the ZrtpStateClass#evInitial() state of the state
+ * engine. After this call we are able to process ZRTP packets
+ * from our peer and to process them.
+ *
+ * <b>NOTE: application shall never call this method directly but use the
+ * appropriate method provided by the RTP implementation. </b>
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ */
+ void zrtp_startZrtpEngine(ZrtpContext* zrtpContext);
+
+ /**
+ * Stop ZRTP security.
+ *
+ * <b>NOTE: An application shall never call this method directly but use the
+ * appropriate method provided by the RTP implementation. </b>
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ */
+ void zrtp_stopZrtpEngine(ZrtpContext* zrtpContext);
+
+ /**
+ * Process RTP extension header.
+ *
+ * This method expects to get a pointer to the message part of
+ * a ZRTP packet.
+ *
+ * <b>NOTE: An application shall never call this method directly. Only
+ * the module that implements the RTP binding shall use this method</b>
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param extHeader
+ * A pointer to the first byte of the ZRTP message part.
+ * @param peerSSRC
+ * The peer's SSRC.
+ * @return
+ * Code indicating further packet handling, see description above.
+ */
+ void zrtp_processZrtpMessage(ZrtpContext* zrtpContext, uint8_t *extHeader, uint32_t peerSSRC);
+
+ /**
+ * Process a timeout event.
+ *
+ * We got a timeout from the timeout provider. Forward it to the
+ * protocol state engine.
+ *
+ * <b>NOTE: application shall never call this method directly. Only
+ * the module that implements the RTP binding shall use this method</b>
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ */
+ void zrtp_processTimeout(ZrtpContext* zrtpContext);
+
+ /*
+ * Check for and handle GoClear ZRTP packet header.
+ *
+ * This method checks if this is a GoClear packet. If not, just return
+ * false. Otherwise handle it according to the specification.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param extHeader
+ * A pointer to the first byte of the extension header. Refer to
+ * RFC3550.
+ * @return
+ * False if not a GoClear, true otherwise.
+ *
+ int32_t zrtp_handleGoClear(ZrtpContext* zrtpContext, uint8_t *extHeader);
+ */
+
+ /**
+ * Set the auxilliary secret.
+ *
+ * Use this method to set the auxilliary secret data. Refer to ZRTP
+ * specification, chapter 4.3 ff
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param data
+ * Points to the secret data.
+ * @param length
+ * Length of the auxilliary secrect in bytes
+ */
+ void zrtp_setAuxSecret(ZrtpContext* zrtpContext, uint8_t* data, int32_t length);
+
+ /**
+ * Check current state of the ZRTP state engine
+ *
+ * <b>NOTE: application usually don't call this method. Only
+ * the m-odule that implements the RTP binding shall use this method</b>
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param state
+ * The state to check.
+ * @return
+ * Returns true if ZRTP engine is in the given state, false otherwise.
+ */
+ int32_t zrtp_inState(ZrtpContext* zrtpContext, int32_t state);
+
+ /**
+ * Set SAS as verified.
+ *
+ * Call this method if the user confirmed (verfied) the SAS. ZRTP
+ * remembers this together with the retained secrets data.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ */
+ void zrtp_SASVerified(ZrtpContext* zrtpContext);
+
+ /**
+ * Reset the SAS verfied flag for the current active user's retained secrets.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ */
+ void zrtp_resetSASVerified(ZrtpContext* zrtpContext);
+
+ /**
+ * Get the ZRTP Hello Hash data.
+ *
+ * Use this method to get the ZRTP Hello Hash data. The method
+ * returns the data as a string containing the ZRTP protocol version and
+ * hex-digits. Refer to ZRTP specification, chapter 8.
+ *
+ * <b>NOTE: An application may call this method if it needs this information.
+ * Usually it is not necessary.</b>
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @return
+ * a pointer to a C-string that contains the Hello hash value as
+ * hex-digits. The hello hash is available immediately after
+ * @c zrtp_CreateWrapper .
+ * The caller must @c free() if it does not use the
+ * hello hash C-string anymore.
+ */
+ char* zrtp_getHelloHash(ZrtpContext* zrtpContext);
+
+ /**
+ * Get the peer's ZRTP Hello Hash data.
+ *
+ * Use this method to get the peer's ZRTP Hello Hash data. The method
+ * returns the data as a string containing the ZRTP protocol version and
+ * hex-digits.
+ *
+ * The peer's hello hash is available only after ZRTP received a hello. If
+ * no data is available the function returns an empty string.
+ *
+ * Refer to ZRTP specification, chapter 8.
+ *
+ * @return
+ * a std:string containing the Hello version and the hello hash as hex digits.
+ */
+ char* zrtp_getPeerHelloHash(ZrtpContext* zrtpContext);
+
+ /**
+ * Get Multi-stream parameters.
+ *
+ * Use this method to get the Multi-stream parameters that were computed
+ * during the ZRTP handshake. An application may use these parameters to
+ * enable multi-stream processing for an associated SRTP session.
+ *
+ * The application must not modify the contents of returned char array, it
+ * is opaque data. The application may hand over this string to a new ZRTP
+ * instance to enable multi-stream processing for this new session.
+ *
+ * Refer to chapter 4.4.2 in the ZRTP specification for further details
+ * and restriction how and when to use multi-stream mode.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param length
+ * Pointer to an integer that receives the length of the char array
+ * @return
+ * a char array that contains the multi-stream parameters.
+ * If ZRTP was not started or ZRTP is not yet in secure state the method
+ * returns NULL and a length of 0.
+ */
+ char* zrtp_getMultiStrParams(ZrtpContext* zrtpContext, int32_t *length);
+
+ /**
+ * Set Multi-stream parameters.
+ *
+ * Use this method to set the parameters required to enable Multi-stream
+ * processing of ZRTP. The multi-stream parameters must be set before the
+ * application starts the ZRTP protocol engine.
+ *
+ * Refer to chapter 4.4.2 in the ZRTP specification for further details
+ * of multi-stream mode.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param length
+ * The integer that contains the length of the char array
+ * @param parameters
+ * A char array that contains the multi-stream parameters that this
+ * new ZRTP instance shall use. See also
+ * <code>getMultiStrParams()</code>
+ */
+ void zrtp_setMultiStrParams(ZrtpContext* zrtpContext, char* parameters, int32_t length);
+
+ /**
+ * Check if this ZRTP session is a Multi-stream session.
+ *
+ * Use this method to check if this ZRTP instance uses multi-stream.
+ * Refer to chapters 4.2 and 4.4.2 in the ZRTP.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @return
+ * True if multi-stream is used, false otherwise.
+ */
+ int32_t zrtp_isMultiStream(ZrtpContext* zrtpContext);
+
+ /**
+ * Check if the other ZRTP client supports Multi-stream.
+ *
+ * Use this method to check if the other ZRTP client supports
+ * Multi-stream mode.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @return
+ * True if multi-stream is available, false otherwise.
+ */
+ int32_t zrtp_isMultiStreamAvailable(ZrtpContext* zrtpContext);
+
+ /**
+ * Accept a PBX enrollment request.
+ *
+ * If a PBX service asks to enroll the PBX trusted MitM key and the user
+ * accepts this request, for example by pressing an OK button, the client
+ * application shall call this method and set the parameter
+ * <code>accepted</code> to true. If the user does not accept the request
+ * set the parameter to false.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param accepted
+ * True if the enrollment request is accepted, false otherwise.
+ */
+ void zrtp_acceptEnrollment(ZrtpContext* zrtpContext, int32_t accepted);
+
+ /**
+ * Check the state of the enrollment mode.
+ *
+ * If true then we will set the enrollment flag (E) in the confirm
+ * packets and performs the enrollment actions. A MitM (PBX) enrollment service
+ * started this ZRTP session. Can be set to true only if mitmMode is also true.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @return status of the enrollmentMode flag.
+ */
+ int32_t zrtp_isEnrollmentMode(ZrtpContext* zrtpContext);
+
+ /**
+ * Check the state of the enrollment mode.
+ *
+ * If true then we will set the enrollment flag (E) in the confirm
+ * packets and perform the enrollment actions. A MitM (PBX) enrollment
+ * service must sets this mode to true.
+ *
+ * Can be set to true only if mitmMode is also true.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param enrollmentMode defines the new state of the enrollmentMode flag
+ */
+ void zrtp_setEnrollmentMode(ZrtpContext* zrtpContext, int32_t enrollmentMode);
+
+ /**
+ * Check if a peer's cache entry has a vaild MitM key.
+ *
+ * If true then the other peer ha a valid MtiM key, i.e. the peer has performed
+ * the enrollment procedure. A PBX ZRTP Back-2-Back application can use this function
+ * to check which of the peers is enrolled.
+ *
+ * @return True if the other peer has a valid Mitm key (is enrolled).
+ */
+ int32_t isPeerEnrolled(ZrtpContext* zrtpContext);
+
+ /**
+ * Send the SAS relay packet.
+ *
+ * The method creates and sends a SAS relay packet according to the ZRTP
+ * specifications. Usually only a MitM capable user agent (PBX) uses this
+ * function.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param sh the full SAS hash value
+ * @param render the SAS rendering algorithm
+ */
+ int32_t zrtp_sendSASRelayPacket(ZrtpContext* zrtpContext, uint8_t* sh, char* render);
+
+ /**
+ * Get the commited SAS rendering algorithm for this ZRTP session.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @return the commited SAS rendering algorithm
+ */
+ const char* zrtp_getSasType(ZrtpContext* zrtpContext);
+
+ /**
+ * Get the computed SAS hash for this ZRTP session.
+ *
+ * A PBX ZRTP back-to-Back function uses this function to get the SAS
+ * hash of an enrolled client to construct the SAS relay packet for
+ * the other client.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @return a pointer to the byte array that contains the full
+ * SAS hash.
+ */
+ uint8_t* zrtp_getSasHash(ZrtpContext* zrtpContext);
+
+ /**
+ * Set signature data
+ *
+ * This functions stores signature data and transmitts it during ZRTP
+ * processing to the other party as part of the Confirm packets. Refer to
+ * chapters 5.7 and 7.2.
+ *
+ * The signature data must be set before ZRTP the application calls
+ * <code>start()</code>.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param data
+ * The signature data including the signature type block. The method
+ * copies this data into the Confirm packet at signature type block.
+ * @param length
+ * The length of the signature data in bytes. This length must be
+ * multiple of 4.
+ * @return
+ * True if the method stored the data, false otherwise.
+ */
+ int32_t zrtp_setSignatureData(ZrtpContext* zrtpContext, uint8_t* data, int32_t length);
+
+ /**
+ * Get signature data
+ *
+ * This functions returns signature data that was receivied during ZRTP
+ * processing. Refer to chapters 5.7 and 7.2.
+ *
+ * The signature data can be retrieved after ZRTP enters secure state.
+ * <code>start()</code>.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @return
+ * Number of bytes copied into the data buffer
+ */
+ const uint8_t* zrtp_getSignatureData(ZrtpContext* zrtpContext);
+
+ /**
+ * Get length of signature data
+ *
+ * This functions returns the length of signature data that was receivied
+ * during ZRTP processing. Refer to chapters 5.7 and 7.2.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @return
+ * Length in bytes of the received signature data. The method returns
+ * zero if no signature data avilable.
+ */
+ int32_t zrtp_getSignatureLength(ZrtpContext* zrtpContext);
+
+ /**
+ * Emulate a Conf2Ack packet.
+ *
+ * This method emulates a Conf2Ack packet. According to ZRTP specification
+ * the first valid SRTP packet that the Initiator receives must switch
+ * on secure mode. Refer to chapter 4 in the specificaton
+ *
+ * <b>NOTE: application shall never call this method directly. Only
+ * the module that implements the RTP binding shall use this method</b>
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ */
+ void zrtp_conf2AckSecure(ZrtpContext* zrtpContext);
+
+ /**
+ * Get other party's ZID (ZRTP Identifier) data
+ *
+ * This functions returns the other party's ZID that was receivied
+ * during ZRTP processing.
+ *
+ * The ZID data can be retrieved after ZRTP receive the first Hello
+ * packet from the other party. The application may call this method
+ * for example during SAS processing in showSAS(...) user callback
+ * method.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param data
+ * Pointer to a data buffer. This buffer must have a size of
+ * at least 12 bytes (96 bit) (ZRTP Identifier, see chap. 4.9)
+ * @return
+ * Number of bytes copied into the data buffer - must be equivalent
+ * to 12 bytes.
+ */
+ int32_t zrtp_getPeerZid(ZrtpContext* zrtpContext, uint8_t* data);
+
+
+ /**
+ * This enumerations list all configurable algorithm types.
+ */
+
+ /* Keep in synch with enumeration in ZrtpConfigure.h */
+
+ typedef enum zrtp_AlgoTypes {
+ zrtp_HashAlgorithm = 1, zrtp_CipherAlgorithm, zrtp_PubKeyAlgorithm, zrtp_SasType, zrtp_AuthLength
+ } Zrtp_AlgoTypes;
+
+ /**
+ * Initialize the GNU ZRTP Configure data.
+ *
+ * Initializing and setting a ZRTP configuration is optional. GNU ZRTP
+ * uses a sensible default if an application does not define its own
+ * ZRTP configuration.
+ *
+ * If an application initialize th configure data it must set the
+ * configuration data.
+ *
+ * The ZRTP specification, chapters 5.1.2 through 5.1.6 defines the
+ * algorithm names and their meaning.
+ *
+ * The current ZRTP implementation implements all mandatory algorithms
+ * plus a set of the optional algorithms. An application shall use
+ * @c zrtp_getAlgorithmNames to get the names of the available algorithms.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @returns
+ * Pointer to the ZrtpConfCtx
+ *
+ * @see zrtp_getAlgorithmNames
+ */
+ int32_t zrtp_InitializeConfig (ZrtpContext* zrtpContext);
+
+ /**
+ * Get names of all available algorithmes of a given algorithm type.
+ *
+ * The algorithm names are as specified in the ZRTP specification, chapters
+ * 5.1.2 through 5.1.6 .
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param type
+ * The algorithm type.
+ * @returns
+ * A NULL terminated array of character pointers.
+ */
+ char** zrtp_getAlgorithmNames(ZrtpContext* zrtpContext, Zrtp_AlgoTypes type);
+
+ /**
+ * Free storage used to store the algorithm names.
+ *
+ * If an application does not longer require the algoritm names it should
+ * free the space.
+ *
+ * @param names
+ * The NULL terminated array of character pointers.
+ */
+ void zrtp_freeAlgorithmNames(char** names);
+
+ /**
+ * Convenience function that sets a pre-defined standard configuration.
+ *
+ * The standard configuration consists of the following algorithms:
+ * <ul>
+ * <li> Hash: SHA256 </li>
+ * <li> Symmetric Cipher: AES 128, AES 256 </li>
+ * <li> Public Key Algorithm: DH2048, DH3027, MultiStream </li>
+ * <li> SAS type: libase 32 </li>
+ * <li> SRTP Authentication lengths: 32, 80 </li>
+ *</ul>
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ */
+ void zrtp_setStandardConfig(ZrtpContext* zrtpContext);
+
+ /**
+ * Convenience function that sets the mandatory algorithms only.
+ *
+ * Mandatory algorithms are:
+ * <ul>
+ * <li> Hash: SHA256 </li>
+ * <li> Symmetric Cipher: AES 128 </li>
+ * <li> Public Key Algorithm: DH3027, MultiStream </li>
+ * <li> SAS type: libase 32 </li>
+ * <li> SRTP Authentication lengths: 32, 80 </li>
+ *</ul>
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ */
+ void zrtp_setMandatoryOnly(ZrtpContext* zrtpContext);
+
+ /**
+ * Clear all configuration data.
+ *
+ * The functions clears all configuration data.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ */
+ void zrtp_confClear(ZrtpContext* zrtpContext);
+
+ /**
+ * Add an algorithm to configuration data.
+ *
+ * Adds the specified algorithm to the configuration data.
+ * If no free configuration data slot is available the
+ * function does not add the algorithm and returns -1. The
+ * methods appends the algorithm to the existing algorithms.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param algoType
+ * Specifies which algorithm type to select
+ * @param algo
+ * The name of the algorithm to add.
+ * @return
+ * Number of free configuration data slots or -1 on error
+ */
+ int32_t zrtp_addAlgo(ZrtpContext* zrtpContext, Zrtp_AlgoTypes algoType, const char* algo);
+
+ /**
+ * Add an algorithm to configuration data at given index
+ *
+ * Adds the specified algorithm to the configuration data vector
+ * at a given index. If the index is larger than the actual size
+ * of the configuration vector the method just appends the algorithm.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param algoType
+ * Specifies which algorithm type to select
+ * @param algo
+ * The name of the algorithm to add.
+ * @param index
+ * The index where to add the algorihm
+ * @return
+ * Number of free configuration data slots or -1 on error
+ */
+ int32_t zrtp_addAlgoAt(ZrtpContext* zrtpContext, Zrtp_AlgoTypes algoType, const char* algo, int32_t index);
+
+ /**
+ * Remove a algorithm from configuration data.
+ *
+ * Removes the specified algorithm from configuration data. If
+ * the algorithm was not configured previously the function does
+ * not modify the configuration data and returns the number of
+ * free configuration data slots.
+ *
+ * If an application removes all algorithms then ZRTP does not
+ * include any algorithm into the hello message and falls back
+ * to a predefined mandatory algorithm.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param algoType
+ * Specifies which algorithm type to select
+ * @param algo
+ * The name of the algorithm to remove.
+ * @return
+ * Number of free configuration slots.
+ */
+ int32_t zrtp_removeAlgo(ZrtpContext* zrtpContext, Zrtp_AlgoTypes algoType, const char* algo);
+
+ /**
+ * Returns the number of configured algorithms.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param algoType
+ * Specifies which algorithm type to select
+ * @return
+ * The number of configured algorithms (used configuration
+ * data slots)
+ */
+ int32_t zrtp_getNumConfiguredAlgos(ZrtpContext* zrtpContext, Zrtp_AlgoTypes algoType);
+
+ /**
+ * Returns the identifier of the algorithm at index.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param algoType
+ * Specifies which algorithm type to select
+ * @param index
+ * The index in the list of the algorihm type
+ * @return
+ * A pointer to the algorithm name. If the index
+ * does not point to a configured slot then the function
+ * returns NULL.
+ *
+ */
+ const char* zrtp_getAlgoAt(ZrtpContext* zrtpContext, Zrtp_AlgoTypes algoType, int32_t index);
+
+ /**
+ * Checks if the configuration data of the algorihm type already contains
+ * a specific algorithms.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param algoType
+ * Specifies which algorithm type to select
+ * @param algo
+ * The name of the algorithm to check
+ * @return
+ * True if the algorithm was found, false otherwise.
+ *
+ */
+ int32_t zrtp_containsAlgo(ZrtpContext* zrtpContext, Zrtp_AlgoTypes algoType, const char* algo);
+
+ /**
+ * Enables or disables trusted MitM processing.
+ *
+ * For further details of trusted MitM processing refer to ZRTP
+ * specification, chapter 7.3
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param yesNo
+ * If set to true then trusted MitM processing is enabled.
+ */
+ void zrtp_setTrustedMitM(ZrtpContext* zrtpContext, int32_t yesNo);
+
+ /**
+ * Check status of trusted MitM processing.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @return
+ * Returns true if trusted MitM processing is enabled.
+ */
+ int32_t zrtp_isTrustedMitM(ZrtpContext* zrtpContext);
+
+ /**
+ * Enables or disables SAS signature processing.
+ *
+ * For further details of trusted MitM processing refer to ZRTP
+ * specification, chapter 7.2
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @param yesNo
+ * If true then certificate processing is enabled.
+ */
+ void zrtp_setSasSignature(ZrtpContext* zrtpContext, int32_t yesNo);
+
+ /**
+ * Check status of SAS signature processing.
+ *
+ * @param zrtpContext
+ * Pointer to the opaque ZrtpContext structure.
+ * @return
+ * Returns true if certificate processing is enabled.
+ */
+ int32_t zrtp_isSasSignature(ZrtpContext* zrtpContext);
+
+#ifdef __cplusplus
+}
+#pragma GCC visibility pop
+#endif
+
+/**
+ * @}
+ */
+#endif
diff --git a/src/libzrtpcpp/ZrtpCallback.h b/src/libzrtpcpp/ZrtpCallback.h
new file mode 100644
index 0000000..957c4dd
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpCallback.h
@@ -0,0 +1,367 @@
+/*
+ Copyright (C) 2006-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 _ZRTPCALLBACK_H_
+#define _ZRTPCALLBACK_H_
+
+/**
+ * @file ZrtpCallback.h
+ * @brief Callback interface between ZRTP and the RTP stack implementation
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <string>
+#include <stdint.h>
+#include <libzrtpcpp/ZrtpCodes.h>
+
+#ifndef __EXPORT
+ #if __GNUC__ >= 4
+ #define __EXPORT __attribute__ ((visibility("default")))
+ #define __LOCAL __attribute__ ((visibility("hidden")))
+ #elif defined _WIN32 || defined __CYGWIN__
+ #define __EXPORT __declspec(dllimport)
+ #define __LOCAL
+ #else
+ #define __EXPORT
+ #define __LOCAL
+ #endif
+#endif
+
+/**
+ * This enum defines which role a ZRTP peer has.
+ *
+ * According to the ZRTP specification the role determines which keys to
+ * use to encrypt or decrypt SRTP data.
+ *
+ * <ul>
+ * <li> The Initiator encrypts SRTP data using the <em>keyInitiator</em> and the
+ * <em>saltInitiator</em> data, the Responder uses these data to decrypt.
+ * </li>
+ * <li> The Responder encrypts SRTP data using the <em>keyResponder</em> and the
+ * <em>saltResponder</em> data, the Initiator uses these data to decrypt.
+ * </li>
+ * </ul>
+ */
+typedef enum {
+ Responder = 1, ///< This client is in ZRTP Responder mode
+ Initiator ///< This client is in ZRTP Initiator mode
+} Role;
+
+/// The algorihms that we support in SRTP and that ZRTP can negotiate.
+typedef enum {
+ None,
+ Aes = 1, ///< Use AES as symmetrical cipher algorithm
+ TwoFish, ///< Use TwoFish as symmetrical cipher algorithm
+ Sha1, ///< Use Sha1 as authentication algorithm
+ Skein ///< Use Skein as authentication algorithm
+} SrtpAlgorithms;
+
+/**
+ * This structure contains pointers to the SRTP secrets and the role info.
+ *
+ * About the role and what the meaning of the role is refer to the
+ * of the enum Role. The pointers to the secrets are valid as long as
+ * the ZRtp object is active. To use these data after the ZRtp object's
+ * lifetime you may copy the data into a save place. The destructor
+ * of ZRtp clears the data.
+ */
+typedef struct srtpSecrets {
+ SrtpAlgorithms symEncAlgorithm; ///< symmetrical cipher algorithm
+ const uint8_t* keyInitiator; ///< Initiator's key
+ int32_t initKeyLen; ///< Initiator's key length
+ const uint8_t* saltInitiator; ///< Initiator's salt
+ int32_t initSaltLen; ///< Initiator's salt length
+ const uint8_t* keyResponder; ///< Responder's key
+ int32_t respKeyLen; ///< Responder's key length
+ const uint8_t* saltResponder; ///< Responder's salt
+ int32_t respSaltLen; ///< Responder's salt length
+ SrtpAlgorithms authAlgorithm; ///< SRTP authentication algorithm
+ int32_t srtpAuthTagLen; ///< SRTP authentication length
+ std::string sas; ///< The SAS string
+ Role role; ///< ZRTP role of this client
+} SrtpSecret_t;
+
+enum EnableSecurity {
+ ForReceiver = 1, ///< Enable security for SRTP receiver
+ ForSender = 2 ///< Enable security for SRTP sender
+};
+
+/**
+ * This abstract class defines the callback functions required by GNU ZRTP.
+ *
+ * This class is a pure abstract class, aka Interface in Java, that
+ * defines the callback interface that the specific part of a GNU ZRTP
+ * must implement. The generic part of GNU ZRTP uses these mehtods
+ * to communicate with the specific part, for example to send data
+ * via the RTP/SRTP stack, to set timers and cancel timer and so on.
+ *
+ * The generiy part of GNU ZRTP needs only a few callback methods to
+ * be implemented by the specific part.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+class __EXPORT ZrtpCallback {
+
+protected:
+ friend class ZRtp;
+
+ virtual ~ZrtpCallback() {};
+
+ /**
+ * Send a ZRTP packet via RTP.
+ *
+ * ZRTP calls this method to send a ZRTP packet via the RTP session.
+ *
+ * @param data
+ * Points to ZRTP packet to send.
+ * @param length
+ * The length in bytes of the data
+ * @return
+ * zero if sending failed, one if packet was send
+ */
+ virtual int32_t sendDataZRTP(const uint8_t* data, int32_t length) =0;
+
+ /**
+ * Activate timer.
+ *
+ * @param time
+ * The time in ms for the timer
+ * @return
+ * zero if activation failed, one if timer was activated
+ */
+ virtual int32_t activateTimer(int32_t time) =0;
+
+ /**
+ * Cancel the active timer.
+ *
+ * @return
+ * zero if cancel action failed, one if timer was canceled
+ */
+ virtual int32_t cancelTimer() =0;
+
+ /**
+ * Send information messages to the hosting environment.
+ *
+ * The ZRTP implementation uses this method to send information
+ * messages to the host. Along with the message ZRTP provides a
+ * severity indicator that defines: Info, Warning, Error,
+ * Alert. Refer to the <code>MessageSeverity</code> enum above.
+ *
+ * @param severity
+ * This defines the message's severity
+ * @param subCode
+ * The subcode identifying the reason.
+ * @see ZrtpCodes#MessageSeverity
+ */
+ virtual void sendInfo(GnuZrtpCodes::MessageSeverity severity, int32_t subCode) =0;
+
+ /**
+ * SRTP crypto data ready for the sender or receiver.
+ *
+ * The ZRTP implementation calls this method right after all SRTP
+ * secrets are computed and ready to be used. The parameter points
+ * to a structure that contains pointers to the SRTP secrets and a
+ * <code>enum Role</code>. The called method (the implementation
+ * of this abstract method) must either copy the pointers to the SRTP
+ * data or the SRTP data itself to a save place. The SrtpSecret_t
+ * structure is destroyed after the callback method returns to the
+ * ZRTP implementation.
+ *
+ * The SRTP data themselfs are ontained in the ZRtp object and are
+ * valid as long as the ZRtp object is active. TheZRtp's
+ * destructor clears the secrets. Thus the called method needs to
+ * save the pointers only, ZRtp takes care of the data.
+ *
+ * The implementing class may enable SRTP processing in this
+ * method or delay it to srtpSecertsOn().
+ *
+ * @param secrets A pointer to a SrtpSecret_t structure that
+ * contains all necessary data.
+ *
+ * @param part for which part (Sender or Receiver) this data is
+ * valid.
+ *
+ * @return Returns false if something went wrong during
+ * initialization of SRTP context, for example memory shortage.
+ */
+ virtual bool srtpSecretsReady(SrtpSecret_t* secrets, EnableSecurity part) =0;
+
+ /**
+ * Switch off the security for the defined part.
+ *
+ * @param part Defines for which part (sender or receiver) to
+ * switch on security
+ */
+ virtual void srtpSecretsOff(EnableSecurity part) =0;
+
+ /**
+ * Switch on the security.
+ *
+ * ZRTP calls this method after it has computed the SAS and check
+ * if it is verified or not. In addition ZRTP provides information
+ * about the cipher algorithm and key length for the SRTP session.
+ *
+ * This method must enable SRTP processing if it was not enabled
+ * during sertSecretsReady().
+ *
+ * @param c The name of the used cipher algorithm and mode, or
+ * NULL
+ *
+ * @param s The SAS string
+ *
+ * @param verified if <code>verified</code> is true then SAS was
+ * verified by both parties during a previous call.
+ */
+ virtual void srtpSecretsOn(std::string c, std::string s, bool verified) =0;
+
+ /**
+ * This method handles GoClear requests.
+ *
+ * According to the ZRTP specification the user must be informed about
+ * a GoClear request because the ZRTP implementation switches off security
+ * if it could authenticate the GoClear packet.
+ *
+ * <b>Note:</b> GoClear is not yet implemented in GNU ZRTP.
+ *
+ */
+ virtual void handleGoClear() =0;
+
+ /**
+ * Handle ZRTP negotiation failed.
+ *
+ * ZRTP calls this method in case ZRTP negotiation failed. The
+ * parameters show the severity as well as the reason.
+ *
+ * @param severity
+ * This defines the message's severity
+ * @param subCode
+ * The subcode identifying the reason.
+ * @see ZrtpCodes#MessageSeverity
+ */
+ virtual void zrtpNegotiationFailed(GnuZrtpCodes::MessageSeverity severity, int32_t subCode) =0;
+
+ /**
+ * ZRTP calls this method if the other side does not support ZRTP.
+ *
+ * If the other side does not answer the ZRTP <em>Hello</em> packets then
+ * ZRTP calls this method,
+ *
+ */
+ virtual void zrtpNotSuppOther() =0;
+
+ /**
+ * Enter synchronization mutex.
+ *
+ * GNU ZRTP requires one mutes to synchronize its
+ * processing. Because mutex implementations depend on the
+ * underlying infrastructure, for example operating system or
+ * thread implementation, GNU ZRTP delegates mutex handling to the
+ * spcific part of its implementation.
+ */
+ virtual void synchEnter() =0;
+
+ /**
+ * Leave synchronization mutex.
+ */
+ virtual void synchLeave() =0;
+
+ /**
+ * Inform about a PBX enrollment request.
+ *
+ * Please refer to chapter 8.3 ff to get more details about PBX
+ * enrollment and SAS relay.
+ *
+ * <b>Note:</b> PBX enrollement is not yet fully supported by GNU
+ * ZRTP.
+ *
+ * @param info Give some information to the user about the PBX
+ * requesting an enrollment.
+ */
+ virtual void zrtpAskEnrollment(GnuZrtpCodes::InfoEnrollment info) =0;
+
+ /**
+ * Inform about PBX enrollment result.
+ *
+ * Informs the use about the acceptance or denial of an PBX enrollment
+ * request
+ *
+ * <b>Note:</b> PBX enrollement is not yet fully supported by GNU
+ * ZRTP.
+ *
+ * @param info information to the user about the result
+ * of an enrollment.
+ */
+ virtual void zrtpInformEnrollment(GnuZrtpCodes::InfoEnrollment info) =0;
+
+ /**
+ * Request a SAS signature.
+ *
+ * After ZRTP was able to compute the Short Authentication String
+ * (SAS) it calls this method. The client may now use an
+ * approriate method to sign the SAS. The client may use
+ * ZrtpQueue#setSignatureData() to store the signature data an
+ * enable signature transmission to the other peer. Refer to
+ * chapter 8.2 of ZRTP specification.
+ *
+ * <b>Note:</b> SAS signing is not yet fully supported by GNU
+ * ZRTP.
+ *
+ * @param sasHash
+ * The SAS hash to sign.
+ *
+ */
+ virtual void signSAS(uint8_t* sasHash) =0;
+
+ /**
+ * ZRTPQueue calls this method to request a SAS signature check.
+ *
+ * After ZRTP received a SAS signature in one of the Confirm packets it
+ * call this method. The client may use <code>getSignatureLength()</code>
+ * and <code>getSignatureData()</code>of ZrtpQueue to get the signature
+ * data and perform the signature check. Refer to chapter 8.2 of ZRTP
+ * specification.
+ *
+ * If the signature check fails the client may return false to ZRTP. In
+ * this case ZRTP signals an error to the other peer and terminates
+ * the ZRTP handshake.
+ *
+ * <b>Note:</b> SAS signing is not yet fully supported by GNU
+ * ZRTP.
+ *
+ * @param sasHash
+ * The SAS hash that was signed by the other peer.
+ * @return
+ * true if the signature was ok, false otherwise.
+ *
+ */
+ virtual bool checkSASSignature(uint8_t* sasHash) =0;
+};
+
+#endif // ZRTPCALLBACK
+
+/**
+ * @}
+ */
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-default-style: ellemtel
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/src/libzrtpcpp/ZrtpCallbackWrapper.h b/src/libzrtpcpp/ZrtpCallbackWrapper.h
new file mode 100644
index 0000000..dd739e0
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpCallbackWrapper.h
@@ -0,0 +1,101 @@
+/*
+ This class maps the ZRTP C++ callback methods to C callback methods.
+ 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 ZRTPCALLBACKWRAPPER_H
+#define ZRTPCALLBACKWRAPPER_H
+
+#include <stdlib.h>
+
+#include <libzrtpcpp/ZrtpCallback.h>
+#include <libzrtpcpp/ZrtpConfigure.h>
+#include <libzrtpcpp/ZrtpCWrapper.h>
+
+/**
+ *
+ * @file ZrtpCallbackWrapper.h
+ * @brief C-Wrapper helper
+ *
+ * This is a helper class for for the C wrapper and implements
+ * the GNU ZRTP callback interface. For detailed documentation about
+ * the callback method refer to file <code>ZrtpCallback</code>
+ * @ingroup GNU_ZRTP
+ * @{
+ *
+ * @see ZrtpCallback
+ * @see ZrtpCWrapper
+ */
+class __EXPORT ZrtpCallbackWrapper : public ZrtpCallback
+{
+public:
+ /**
+ * Construct a class that implements ZrtpCallback and uses a C structure
+ * to call C functions that implement the callbacks.
+ *
+ * @param cb
+ * The C callback structure that hold the addresses of the C methods
+ * that implement the actual callback functions.
+ * @param ctx
+ * Pointer to the ZrtpContext
+ */
+ ZrtpCallbackWrapper(zrtp_Callbacks* cb, ZrtpContext* ctx);
+
+ int32_t sendDataZRTP ( const unsigned char* data, int32_t length );
+
+ int32_t activateTimer ( int32_t time );
+
+ int32_t cancelTimer();
+
+ void sendInfo ( GnuZrtpCodes::MessageSeverity severity, int32_t subCode );
+
+ bool srtpSecretsReady ( SrtpSecret_t* secrets, EnableSecurity part );
+
+ void srtpSecretsOff ( EnableSecurity part );
+
+ void srtpSecretsOn ( std::string c, std::string s, bool verified );
+
+ void handleGoClear();
+
+ void zrtpNegotiationFailed ( GnuZrtpCodes::MessageSeverity severity, int32_t subCode );
+
+ void zrtpNotSuppOther();
+
+ void synchEnter();
+
+ void synchLeave();
+
+ void zrtpAskEnrollment (GnuZrtpCodes::InfoEnrollment info );
+
+ void zrtpInformEnrollment (GnuZrtpCodes::InfoEnrollment info );
+
+ void signSAS (uint8_t* sasHash );
+
+ bool checkSASSignature (uint8_t* sasHash );
+
+private:
+ void init();
+ zrtp_Callbacks *c_callbacks;
+ ZrtpContext* zrtpCtx;
+
+};
+
+/**
+ * @}
+ */
+
+#endif // ZRTPCALLBACKWRAPPER_H
diff --git a/src/libzrtpcpp/ZrtpCodes.h b/src/libzrtpcpp/ZrtpCodes.h
new file mode 100755
index 0000000..a1bb6fc
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpCodes.h
@@ -0,0 +1,164 @@
+/** @file ZrtpCodes.h
+ */
+/*
+ Copyright (C) 2006-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 _ZRTPCODES_H_
+#define _ZRTPCODES_H_
+/**
+ * @file ZrtpCodes.h
+ * @brief The ZRTP info, warning, and error codes
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+namespace GnuZrtpCodes {
+/**
+ * \namespace GnuZrtpCodes
+ *
+ * This enum defines the information message severity.
+ *
+ * The ZRTP implementation issues information messages to inform the user
+ * about ongoing processing, unusual behavior, or alerts in case of severe
+ * problems. Each main severity code a number of sub-codes exist that
+ * specify the exact nature of the problem.
+ *
+ * An application gets message severity codes and the associated sub-codes
+ * via the ZrtpUserCallback#showMessage method.
+ *
+ * The severity levels and their meaning are:
+ *
+ * <dl>
+ * <dt>Info</dt> <dd>keeps the user informed about ongoing processing and
+ * security setup. The enumeration InfoCodes defines the subcodes.
+ * </dd>
+ * <dt>Warning</dt> <dd>is an information about some security issues, e.g. if
+ * an AES 256 encryption is request but only DH 3072 as public key scheme
+ * is supported. ZRTP will establish a secure session (SRTP). The
+ * enumeration WarningCodes defines the sub-codes.
+ * </dd>
+ * <dt>Severe</dt> <dd>is used if an error occured during ZRTP protocol usage.
+ * In case of <em>Severe</em> ZRTP will <b>not</b> establish a secure session.
+ * The enumeration SevereCodes defines the sub-codes.
+ * </dd>
+ * <dt>Zrtp</dt> <dd>shows a ZRTP security problem. Refer to the enumeration
+ * ZrtpErrorCodes for sub-codes. GNU ZRTP of course will <b>not</b>
+ * establish a secure session.
+ * </dd>
+ * </dl>
+ *
+ */
+enum MessageSeverity {
+ Info = 1,
+ Warning,
+ Severe,
+ ZrtpError
+};
+
+/**
+ * Sub-codes for Info
+ */
+enum InfoCodes {
+ InfoHelloReceived = 1, //!< Hello received, preparing a Commit
+ InfoCommitDHGenerated, //!< Commit: Generated a public DH key
+ InfoRespCommitReceived, //!< Responder: Commit received, preparing DHPart1
+ InfoDH1DHGenerated, //!< DH1Part: Generated a public DH key
+ InfoInitDH1Received, //!< Initiator: DHPart1 received, preparing DHPart2
+ InfoRespDH2Received, //!< Responder: DHPart2 received, preparing Confirm1
+ InfoInitConf1Received, //!< Initiator: Confirm1 received, preparing Confirm2
+ InfoRespConf2Received, //!< Responder: Confirm2 received, preparing Conf2Ack
+ InfoRSMatchFound, //!< At least one retained secrets matches - security OK
+ InfoSecureStateOn, //!< Entered secure state
+ InfoSecureStateOff //!< No more security for this session
+};
+
+/**
+ * Sub-codes for Warning
+ */
+enum WarningCodes {
+ WarningDHAESmismatch = 1, //!< Commit contains an AES256 cipher but does not offer a Diffie-Helman 4096
+ WarningGoClearReceived, //!< Received a GoClear message
+ WarningDHShort, //!< Hello offers an AES256 cipher but does not offer a Diffie-Helman 4096
+ WarningNoRSMatch, //!< No retained shared secrets available - must verify SAS
+ WarningCRCmismatch, //!< Internal ZRTP packet checksum mismatch - packet dropped
+ WarningSRTPauthError, //!< Dropping packet because SRTP authentication failed!
+ WarningSRTPreplayError, //!< Dropping packet because SRTP replay check failed!
+ WarningNoExpectedRSMatch //!< Valid retained shared secrets availabe but no matches found - must verify SAS
+};
+
+/**
+ * Sub-codes for Severe
+ */
+enum SevereCodes {
+ SevereHelloHMACFailed = 1, //!< Hash HMAC check of Hello failed!
+ SevereCommitHMACFailed, //!< Hash HMAC check of Commit failed!
+ SevereDH1HMACFailed, //!< Hash HMAC check of DHPart1 failed!
+ SevereDH2HMACFailed, //!< Hash HMAC check of DHPart2 failed!
+ SevereCannotSend, //!< Cannot send data - connection or peer down?
+ SevereProtocolError, //!< Internal protocol error occured!
+ SevereNoTimer, //!< Cannot start a timer - internal resources exhausted?
+ SevereTooMuchRetries //!< Too much retries during ZRTP negotiation - connection or peer down?
+};
+
+/**
+ * Error codes according to the ZRTP specification chapter 6.9
+ *
+ * GNU ZRTP uses these error codes in two ways: to fill the appropriate
+ * field ing the ZRTP Error packet and as sub-code in
+ * ZrtpUserCallback#showMessage(). GNU ZRTP uses thes error codes also
+ * to report received Error packts, in this case the sub-codes are their
+ * negative values.
+ *
+ * The enumeration member comments are copied from the ZRTP specification.
+ */
+enum ZrtpErrorCodes {
+ MalformedPacket = 0x10, //!< Malformed packet (CRC OK, but wrong structure)
+ CriticalSWError = 0x20, //!< Critical software error
+ UnsuppZRTPVersion = 0x30, //!< Unsupported ZRTP version
+ HelloCompMismatch = 0x40, //!< Hello components mismatch
+ UnsuppHashType = 0x51, //!< Hash type not supported
+ UnsuppCiphertype = 0x52, //!< Cipher type not supported
+ UnsuppPKExchange = 0x53, //!< Public key exchange not supported
+ UnsuppSRTPAuthTag = 0x54, //!< SRTP auth. tag not supported
+ UnsuppSASScheme = 0x55, //!< SAS scheme not supported
+ NoSharedSecret = 0x56, //!< No shared secret available, DH mode required
+ DHErrorWrongPV = 0x61, //!< DH Error: bad pvi or pvr ( == 1, 0, or p-1)
+ DHErrorWrongHVI = 0x62, //!< DH Error: hvi != hashed data
+ SASuntrustedMiTM = 0x63, //!< Received relayed SAS from untrusted MiTM
+ ConfirmHMACWrong = 0x70, //!< Auth. Error: Bad Confirm pkt HMAC
+ NonceReused = 0x80, //!< Nonce reuse
+ EqualZIDHello = 0x90, //!< Equal ZIDs in Hello
+ GoCleatNotAllowed = 0x100, //!< GoClear packet received, but not allowed
+ IgnorePacket = 0x7fffffff
+};
+
+/**
+ * Information codes for the Enrollment user callbacks.
+ */
+enum InfoEnrollment {
+ EnrollmentRequest, //!< Aks user to confirm or deny an Enrollemnt request
+ EnrollmentCanceled, //!< User did not confirm the PBX enrollement
+ EnrollmentFailed, //!< Enrollment process failed, no PBX secret available
+ EnrollmentOk //!< Enrollment process for this PBX was ok
+};
+
+}
+
+/**
+ * @}
+ */
+#endif
diff --git a/src/libzrtpcpp/ZrtpConfigure.h b/src/libzrtpcpp/ZrtpConfigure.h
new file mode 100644
index 0000000..33a824f
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpConfigure.h
@@ -0,0 +1,551 @@
+/*
+ Copyright (C) 2009 - 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#ifndef _ZRTPCONFIGURE_H_
+#define _ZRTPCONFIGURE_H_
+
+/**
+ * @file ZrtpConfigure.h
+ * @brief The ZRTP configure functions
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <list>
+#include <string>
+#include <vector>
+#include <string.h>
+
+#include <libzrtpcpp/ZrtpCallback.h>
+
+/**
+ * This enumerations list all configurable algorithm types.
+ */
+
+enum AlgoTypes {
+ Invalid = 0, HashAlgorithm = 1, CipherAlgorithm, PubKeyAlgorithm, SasType, AuthLength
+};
+
+typedef void(*encrypt_t)(uint8_t*, int32_t, uint8_t*, uint8_t*, int32_t);
+typedef void(*decrypt_t)(uint8_t*, int32_t, const uint8_t*, uint8_t*, int32_t);
+
+/**
+ * The algorithm enumration class.
+ *
+ * This simple class is just a container of an algorithm's name and
+ * its associated algorithm type. We use this class together with the
+ * EnumBase class to implement a Java-like enum class functionality
+ * (not fully, but OK for our use case).
+ *
+ * An application shall use the get / check methods to retrieve information.
+ */
+class AlgorithmEnum {
+public:
+ /**
+ * Create an AlgorithmEnum object.
+ *
+ * @param type
+ * Defines the algorithm type
+ * @param name
+ * Set the names of the algorithm. The name is copied
+ * and the call may reuse the space.
+ * @param klen
+ * The key length for this algorihm in byte, for example 16 or 32
+ * @param ra
+ * A human readable short string that describes the algorihm.
+ * @param en
+ * Pointer to the encryption function of this algorithn
+ * @param de
+ * Pointer to the decryption funtions of this algorithm.
+ * @param alId
+ * The algorithm id used by SRTP to identify an algorithm type, for
+ * example Skein, Sha1, Aes, ...
+ *
+ * @see AlgoTypes
+ */
+ AlgorithmEnum(const AlgoTypes type, const char* name, int32_t klen,
+ const char* ra, encrypt_t en, decrypt_t de, SrtpAlgorithms alId);
+
+ /**
+ * AlgorithmEnum destructor
+ */
+ ~AlgorithmEnum();
+
+ /**
+ * Get the algorihm's name
+ *
+ * @returns
+ * Algorithm's name as null terminated C-string. The
+ * application must not free this memory.
+ */
+ const char* getName();
+
+ /**
+ * Get the algorihm's readable name
+ *
+ * @returns
+ * Algorithm's readable name as null terminated C-string. The
+ * application must not free this memory.
+ */
+ const char* getReadable();
+
+ /**
+ * Get the algorihm's key length.
+ *
+ * @returns
+ * An integer definig the key length in bytes.
+ */
+ int getKeylen();
+
+ /**
+ * Get the algorihm's integer id.
+ *
+ * @returns
+ * An integer that defines the algorithm.
+ */
+ SrtpAlgorithms getAlgoId();
+ /**
+ * Get the algorihm's key length.
+ *
+ * @returns
+ * An integer definig the key length in bytes.
+ */
+ encrypt_t getEncrypt();
+
+ /**
+ * Get the algorihm's key length.
+ *
+ * @returns
+ * An integer definig the key length in bytes.
+ */
+ decrypt_t getDecrypt();
+
+ /**
+ * Get the algorithm type of this AlgorithmEnum object.
+ *
+ * @returns
+ * The algorithm type.
+ *
+ * @see AlgoTypes
+ */
+ AlgoTypes getAlgoType();
+
+ /**
+ * Check if this AlgorithmEnum object is valid
+ *
+ * @returns
+ * @c true if the object is valid, @c false otherwise
+ */
+ bool isValid();
+
+private:
+ AlgoTypes algoType;
+ std::string algoName;
+ int32_t keyLen;
+ std::string readable;
+ encrypt_t encrypt;
+ decrypt_t decrypt;
+ SrtpAlgorithms algoId;
+};
+
+/**
+ * EnumBase provides methods to store and access algorithm enumerations of
+ * a specific algorithm type.
+ *
+ * An application shall use the get / check methods to retrieve information
+ * from the preset Algorithm Enumerations.
+ *
+ * @see AlgoTypes
+ * @see zrtpHashes
+ * @see zrtpSymCiphers
+ * @see zrtpPubKeys
+ * @see zrtpSasTypes
+ * @see zrtpAuthLengths
+ */
+class EnumBase {
+public:
+ /**
+ * Get an AlgorithmEnum by its name
+ *
+ * @param name
+ * The name of the AlgorithmEnum to search.
+ * @returns
+ * The AlgorithmEnum if found or an invalid AlgorithmEnum if the name
+ * was not found
+ */
+ AlgorithmEnum& getByName(const char* name);
+
+ /**
+ * Return all names of all currently stored AlgorithmEnums
+ *
+ * @return
+ * A C++ std::list of C++ std::strings that contain the names.
+ */
+ std::list<std::string>* getAllNames();
+
+ /**
+ * Get the number of currently stored AlgorithmEnums
+ *
+ * @return
+ * The number of currently stored AlgorithmEnums
+ */
+ int getSize();
+
+ /**
+ * Get the AlgoTypes to which this EnumBase belongs.
+ *
+ * @return
+ * The AlgoTypes of this EnumBase.
+ * @see AlgoTypes.
+ */
+ AlgoTypes getAlgoType();
+
+ /**
+ * Return the AlgorithmEnum by its ordinal number
+ *
+ * @param ord
+ * The ordinal number of the AlgorithmEnum.
+ * @return
+ * The AlgorithmEnum if found, an invalid Algorithm otherwise.
+ */
+ AlgorithmEnum& getByOrdinal(int ord);
+
+ /**
+ * Get the ordinal number of an AlgorithmEnum
+ *
+ * @param algo
+ * Return toe ordinal numer of this AlgorithmEnum.
+ *
+ * @return
+ * Return the ordinal number of this AlgorithmEnum if found,
+ * -1 otherwise.
+ */
+ int getOrdinal(AlgorithmEnum& algo);
+
+protected:
+ EnumBase(AlgoTypes algo);
+ ~EnumBase();
+ void insert(const char* name);
+ void insert(const char* name, int32_t klen,
+ const char* ra, encrypt_t en, decrypt_t de, SrtpAlgorithms alId);
+
+private:
+ AlgoTypes algoType;
+ std::vector <AlgorithmEnum* > algos;
+};
+
+/**
+ * The enumaration subclasses that contain the supported algorithm enumerations.
+ */
+class HashEnum : public EnumBase {
+public:
+ HashEnum();
+ ~HashEnum();
+};
+
+class SymCipherEnum : public EnumBase {
+public:
+ SymCipherEnum();
+ ~SymCipherEnum();
+};
+
+class PubKeyEnum : public EnumBase {
+public:
+ PubKeyEnum();
+ ~PubKeyEnum();
+};
+
+class SasTypeEnum : public EnumBase {
+public:
+ SasTypeEnum();
+ ~SasTypeEnum();
+};
+
+class AuthLengthEnum : public EnumBase {
+public:
+ AuthLengthEnum();
+ ~AuthLengthEnum();
+};
+
+extern HashEnum zrtpHashes;
+extern SymCipherEnum zrtpSymCiphers;
+extern PubKeyEnum zrtpPubKeys;
+extern SasTypeEnum zrtpSasTypes;
+extern AuthLengthEnum zrtpAuthLengths;
+
+/**
+ * ZRTP configuration data.
+ *
+ * This class contains data and functions to set ZRTP configuration data.
+ * An application may use this class to set configuration information for
+ * ZRTP. ZRTP uses this configuration information to announce various
+ * algorithms via its Hello message. An application may use this class to
+ * restrict or allow use of algorithms.
+ *
+ * The constructor does not set any algorithms, thus it is an empty
+ * configuration. An application may use this empty configuration and
+ * hand it over to ZRTP. In this case ZRTP does not announce any algorithms
+ * in its Hello message and uses mandatory algorithms only.
+ *
+ * An application can configure implemented algorithms only.
+ */
+class __EXPORT ZrtpConfigure {
+public:
+ ZrtpConfigure(); /* Creates Configuration data */
+ ~ZrtpConfigure();
+
+ /**
+ * Set the maximum number of algorithms per algorithm type that an application can
+ * configure.
+ */
+ static const int maxNoOfAlgos = 7;
+ /**
+ * Convenience function that sets a pre-defined standard configuration.
+ *
+ * The standard configuration consists of the following algorithms:
+ * <ul>
+ * <li> Hash: SHA256 </li>
+ * <li> Symmetric Cipher: AES 128, AES 256 </li>
+ * <li> Public Key Algorithm: DH2048, DH3027, MultiStream </li>
+ * <li> SAS type: libase 32 </li>
+ * <li> SRTP Authentication lengths: 32, 80 </li>
+ *</ul>
+ */
+ void setStandardConfig();
+
+ /**
+ * Convenience function that sets the mandatory algorithms only.
+ *
+ * Mandatory algorithms are:
+ * <ul>
+ * <li> Hash: SHA256 </li>
+ * <li> Symmetric Cipher: AES 128 </li>
+ * <li> Public Key Algorithm: DH3027, MultiStream </li>
+ * <li> SAS type: libase 32 </li>
+ * <li> SRTP Authentication lengths: 32, 80 </li>
+ *</ul>
+ */
+ void setMandatoryOnly();
+
+ /**
+ * Clear all configuration data.
+ *
+ * The functions clears all configuration data.
+ */
+ void clear();
+
+ /**
+ * Add an algorithm to configuration data.
+ *
+ * Adds the specified algorithm to the configuration data.
+ * If no free configuration data slot is available the
+ * function does not add the algorithm and returns -1. The
+ * methods appends the algorithm to the existing algorithms.
+ *
+ * @param algoType
+ * Specifies which algorithm type to select
+ * @param algo
+ * The enumeration of the algorithm to add.
+ * @return
+ * Number of free configuration data slots or -1 on error
+ */
+ int32_t addAlgo(AlgoTypes algoType, AlgorithmEnum& algo);
+
+ /**
+ * Add an algorithm to configuration data at given index.
+ *
+ * Adds the specified algorithm to the configuration data vector
+ * at a given index. If the index is larger than the actual size
+ * of the configuration vector the method just appends the algorithm.
+ *
+ * @param algoType
+ * Specifies which algorithm type to select
+ * @param algo
+ * The enumeration of the algorithm to add.
+ * @param index
+ * The index where to add the algorihm
+ * @return
+ * Number of free configuration data slots or -1 on error
+ */
+ int32_t addAlgoAt(AlgoTypes algoType, AlgorithmEnum& algo, int32_t index);
+
+ /**
+ * Remove a algorithm from configuration data.
+ *
+ * Removes the specified algorithm from configuration data. If
+ * the algorithm was not configured previously the function does
+ * not modify the configuration data and returns the number of
+ * free configuration data slots.
+ *
+ * If an application removes all algorithms then ZRTP does not
+ * include any algorithm into the hello message and falls back
+ * to a predefined mandatory algorithm.
+ *
+ * @param algoType
+ * Specifies which algorithm type to select
+ * @param algo
+ * The enumeration of the algorithm to remove.
+ * @return
+ * Number of free configuration slots.
+ */
+ int32_t removeAlgo(AlgoTypes algoType, AlgorithmEnum& algo);
+
+ /**
+ * Returns the number of configured algorithms.
+ *
+ * @param algoType
+ * Specifies which algorithm type to select
+ * @return
+ * The number of configured algorithms (used configuration
+ * data slots)
+ */
+ int32_t getNumConfiguredAlgos(AlgoTypes algoType);
+
+ /**
+ * Returns the identifier of the algorithm at index.
+ *
+ * @param algoType
+ * Specifies which algorithm type to select
+ * @param index
+ * The index in the list of the algorihm type
+ * @return
+ * A pointer the the algorithm enumeration. If the index
+ * does not point to a configured slot then the function
+ * returns NULL.
+ *
+ */
+ AlgorithmEnum& getAlgoAt(AlgoTypes algoType, int32_t index);
+
+ /**
+ * Checks if the configuration data of the algorihm type already contains
+ * a specific algorithms.
+ *
+ * @param algoType
+ * Specifies which algorithm type to select
+ * @param algo
+ * The algorithm to check
+ * @return
+ * True if the algorithm was found, false otherwise.
+ *
+ */
+ bool containsAlgo(AlgoTypes algoType, AlgorithmEnum& algo);
+
+ /**
+ * Enables or disables trusted MitM processing.
+ *
+ * For further details of trusted MitM processing refer to ZRTP
+ * specification, chapter 7.3
+ *
+ * @param yesNo
+ * If set to true then trusted MitM processing is enabled.
+ */
+ void setTrustedMitM(bool yesNo);
+
+ /**
+ * Check status of trusted MitM processing.
+ *
+ * @return
+ * Returns true if trusted MitM processing is enabled.
+ */
+ bool isTrustedMitM();
+
+ /**
+ * Enables or disables SAS signature processing.
+ *
+ * For further details of trusted MitM processing refer to ZRTP
+ * specification, chapter 7.2
+ *
+ * @param yesNo
+ * If set to true then certificate processing is enabled.
+ */
+ void setSasSignature(bool yesNo);
+
+ /**
+ * Check status of SAS signature processing.
+ *
+ * @return
+ * Returns true if certificate processing is enabled.
+ */
+ bool isSasSignature();
+
+ /**
+ * Enables or disables paranoid mode.
+ *
+ * For further explanation of paranoid mode refer to the documentation
+ * of ZRtp class.
+ *
+ * @param yesNo
+ * If set to true then paranoid mode is enabled.
+ */
+ void setParanoidMode(bool yesNo);
+
+ /**
+ * Check status of paranoid mode.
+ *
+ * @return
+ * Returns true if paranoid mode is enabled.
+ */
+ bool isParanoidMode();
+
+ /// Helper function to print some internal data
+ void printConfiguredAlgos(AlgoTypes algoTyp);
+
+ private:
+ std::vector<AlgorithmEnum* > hashes;
+ std::vector<AlgorithmEnum* > symCiphers;
+ std::vector<AlgorithmEnum* > publicKeyAlgos;
+ std::vector<AlgorithmEnum* > sasTypes;
+ std::vector<AlgorithmEnum* > authLengths;
+
+ bool enableTrustedMitM;
+ bool enableSasSignature;
+ bool enableParanoidMode;
+
+
+ AlgorithmEnum& getAlgoAt(std::vector<AlgorithmEnum* >& a, int32_t index);
+ int32_t addAlgo(std::vector<AlgorithmEnum* >& a, AlgorithmEnum& algo);
+ int32_t addAlgoAt(std::vector<AlgorithmEnum* >& a, AlgorithmEnum& algo, int32_t index);
+ int32_t removeAlgo(std::vector<AlgorithmEnum* >& a, AlgorithmEnum& algo);
+ int32_t getNumConfiguredAlgos(std::vector<AlgorithmEnum* >& a);
+ bool containsAlgo(std::vector<AlgorithmEnum* >& a, AlgorithmEnum& algo);
+ std::vector<AlgorithmEnum* >& getEnum(AlgoTypes algoType);
+
+ void printConfiguredAlgos(std::vector<AlgorithmEnum* >& a);
+
+ protected:
+
+ public:
+};
+
+/**
+ * @}
+ */
+#endif
+
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-default-style: ellemtel
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/src/libzrtpcpp/ZrtpCrc32.h b/src/libzrtpcpp/ZrtpCrc32.h
new file mode 100755
index 0000000..ad57edd
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpCrc32.h
@@ -0,0 +1,75 @@
+/*
+ Copyright (C) 2006-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 _ZRTPCRC32_H_
+#define _ZRTPCRC32_H_
+
+/**
+ *
+ * @file ZrtpCrc32.h
+ * @brief Methods to compute the CRC32 checksum for ZRTP packets
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ *
+ * @see ZrtpCallback
+ */
+
+/**
+ * Check if a buffer matches a given CRC32 checksum.
+ *
+ * @param buffer
+ * Pointer to the data buffer.
+ * @param length
+ * Length in bytes of the data buffer.
+ * @param crc32
+ * The CRC32 checksum.
+ *
+ * @return
+ * @c true if the CRC32 checksum matches the computed checksum of the
+ * buffer, @c false otherwise.
+ */
+bool zrtpCheckCksum(uint8_t *buffer, uint16_t length, uint32_t crc32);
+
+/**
+ * Generate a CRC32 checksum of a data buffer
+ *
+ * @param buffer
+ * Pointer to the buffer.
+ * @param length
+ * Lenght of the buffer in bytes.
+ *
+ * @return
+ * A preliminary CRC32 checksum
+ */
+uint32_t zrtpGenerateCksum(uint8_t *buffer, uint16_t length);
+
+/**
+ * Close CRC32 computation.
+ *
+ * @param crc32
+ * A preliminary CRC32 checksum.
+ *
+ * @return
+ * The ready to use CRC32 checksum in host order.
+ */
+uint32_t zrtpEndCksum(uint32_t crc32);
+
+/**
+ * @}
+ */
+#endif
diff --git a/src/libzrtpcpp/ZrtpPacketBase.h b/src/libzrtpcpp/ZrtpPacketBase.h
new file mode 100644
index 0000000..f0d2944
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpPacketBase.h
@@ -0,0 +1,147 @@
+/*
+ Copyright (C) 2006-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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#ifndef _ZRTPPACKETBASE_H_
+#define _ZRTPPACKETBASE_H_
+
+/**
+ * @file ZrtpPacketBase.h
+ * @brief The ZRTP message header class
+ *
+ * This class defines the ZRTP message header and provides access and
+ * check methods.
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+
+#if defined(_MSC_VER) || defined(WIN32) || defined(_WIN32)
+#include <winsock2.h>
+#else
+#include <netinet/in.h>
+#endif
+
+#include <libzrtpcpp/zrtpPacket.h>
+#include <libzrtpcpp/ZrtpTextData.h>
+#include <libzrtpcpp/ZrtpConfigure.h>
+#include <libzrtpcpp/ZrtpCrc32.h>
+
+// #define DEBUGOUT(deb) deb
+#define DEBUGOUT(deb)
+
+/*
+ * This is the unique ZRTP ID in network order (PZ)
+ */
+const uint16_t zrtpId = 0x505a;
+
+/**
+ * This is the base class for all ZRTP packets
+ *
+ * All other ZRTP packet classes inherit from this class. It does not have
+ * an implementation of its own.
+ *
+ * The standard constructors of the subclasses usually initialize the @c allocate
+ * field with their fixed data array which is large enough to hold all message
+ * data. If an implementation needs to change this to use dynamic memory
+ * allocation only that line in the subclasses must be changed and the destructors
+ * should take care of memory management.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+class __EXPORT ZrtpPacketBase {
+
+ private:
+
+ protected:
+ void* allocated; ///< Pointer to ZRTP message data
+ zrtpPacketHeader_t* zrtpHeader; ///< points to the fixed ZRTP header structure
+
+ public:
+ /**
+ * Destructor is empty
+ */
+ virtual ~ZrtpPacketBase() {};
+
+ /**
+ * Get pointer to ZRTP header
+ *
+ * @return
+ * Pointer to ZRTP header structure.
+ */
+ const uint8_t* getHeaderBase() { return (const uint8_t*)zrtpHeader; };
+
+ /**
+ * Check is this is a ZRTP message
+ *
+ * @return
+ * @c true if check was ok
+ */
+ bool isZrtpPacket() { return (ntohs(zrtpHeader->zrtpId) == zrtpId); };
+
+ /**
+ * Get the length in words of the ZRTP message
+ *
+ * @return
+ * The length in words
+ */
+ uint16_t getLength() { return ntohs(zrtpHeader->length); };
+
+ /**
+ * Return pointer to fixed length message type ASCII data
+ *
+ * @return
+ * Pointer to ASCII character array
+ */
+ uint8_t* getMessageType() { return zrtpHeader->messageType; };
+
+ /**
+ * Set the lenght field in the ZRTP header
+ *
+ * @param len
+ * The length of the ZRTP message in words, host order
+ */
+ void setLength(uint16_t len) { zrtpHeader->length = htons(len); };
+
+ /**
+ * Copy the message type ASCII data to ZRTP message type field
+ *
+ * @param msg
+ * Pointer to message type ASCII character array
+ */
+ void setMessageType(uint8_t *msg)
+ { memcpy(zrtpHeader->messageType, msg, sizeof(zrtpHeader->messageType)); };
+
+ /**
+ * Initializes the ZRTP Id field
+ */
+ void setZrtpId() { zrtpHeader->zrtpId = htons(zrtpId); }
+};
+
+/**
+ * @}
+ */
+#endif // ZRTPPACKETBASE
diff --git a/src/libzrtpcpp/ZrtpPacketClearAck.h b/src/libzrtpcpp/ZrtpPacketClearAck.h
new file mode 100644
index 0000000..992f6d8
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpPacketClearAck.h
@@ -0,0 +1,54 @@
+/*
+ Copyright (C) 2006-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 _ZRTPPACKETCLEARACK_H_
+#define _ZRTPPACKETCLEARACK_H_
+
+/**
+ * @file ZrtpPacketClearAck.h
+ * @brief The ZRTP ClearAck message
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <libzrtpcpp/ZrtpPacketBase.h>
+
+/**
+ * Implement the ClearAck packet - Currently not used
+ *
+ * The ZRTP simple message ClearAck. The implementation sends this
+ * after switching to clear mode (non-SRTP mode).
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+class __EXPORT ZrtpPacketClearAck : public ZrtpPacketBase {
+
+ public:
+ ZrtpPacketClearAck(); /// Creates a ClearAck packet with default data
+ ZrtpPacketClearAck(uint8_t* data); /// Creates a ClearAck packet from received data
+ virtual ~ZrtpPacketClearAck();
+
+ private:
+ ClearAckPacket_t data;
+};
+
+/**
+ * @}
+ */
+#endif // ZRTPPACKETCLEARACK
+
diff --git a/src/libzrtpcpp/ZrtpPacketCommit.h b/src/libzrtpcpp/ZrtpPacketCommit.h
new file mode 100644
index 0000000..b23b23d
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpPacketCommit.h
@@ -0,0 +1,134 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+#ifndef _ZRTPPACKETCOMMIT_H_
+#define _ZRTPPACKETCOMMIT_H_
+
+/**
+ * @file ZrtpPacketCommit.h
+ * @brief The ZRTP Commit message
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <libzrtpcpp/ZrtpPacketBase.h>
+
+/**
+ * Implement the Commit packet.
+ *
+ * The ZRTP message Commit. The ZRTP implementation sends or receives
+ * this message to commit the crypto parameters offered during a Hello
+ * message.
+ *
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+class __EXPORT ZrtpPacketCommit : public ZrtpPacketBase {
+
+ protected:
+ Commit_t* commitHeader; ///< Points to Commit message part
+
+ public:
+ /// Creates a Commit packet with default data
+ ZrtpPacketCommit();
+
+ /// Creates a Commit packet from received data
+ ZrtpPacketCommit(uint8_t* data);
+
+ /// Normal destructor
+ virtual ~ZrtpPacketCommit();
+
+ /// Get pointer to hash algorithm type field, a fixed length character array
+ uint8_t* getHashType() { return commitHeader->hash; };
+
+ /// Get pointer to cipher algorithm type field, a fixed length character array
+ uint8_t* getCipherType() { return commitHeader->cipher; };
+
+ /// Get pointer to SRTP authentication algorithm type field, a fixed length character array
+ uint8_t* getAuthLen() { return commitHeader->authlengths; };
+
+ /// Get pointer to key agreement algorithm type field, a fixed length character array
+ uint8_t* getPubKeysType() { return commitHeader->pubkey; };
+
+ /// Get pointer to SAS algorithm type field, a fixed length character array
+ uint8_t* getSasType() { return commitHeader->sas; };
+
+ /// Get pointer to ZID field, a fixed length byte array
+ uint8_t* getZid() { return commitHeader->zid; };
+
+ /// Get pointer to HVI field, a fixed length byte array
+ uint8_t* getHvi() { return commitHeader->hvi; };
+
+ /// Get pointer to NONCE field, a fixed length byte array, overlaps HVI field
+ uint8_t* getNonce() { return commitHeader->hvi; };
+
+ /// Get pointer to hashH2 field, a fixed length byte array
+ uint8_t* getH2() { return commitHeader->hashH2; };
+
+ /// Get pointer to MAC field, a fixed length byte array
+ uint8_t* getHMAC() { return commitHeader->hmac; };
+
+ /// Get pointer to MAC field during multi-stream mode, a fixed length byte array
+ uint8_t* getHMACMulti() { return commitHeader->hmac-4*ZRTP_WORD_SIZE; };
+
+ /// Set hash algorithm type field, fixed length character field
+ void setHashType(uint8_t* text) { memcpy(commitHeader->hash, text, ZRTP_WORD_SIZE); };
+
+ /// Set cipher algorithm type field, fixed length character field
+ void setCipherType(uint8_t* text) { memcpy(commitHeader->cipher, text, ZRTP_WORD_SIZE); };
+
+ /// Set SRTP authentication algorithm algorithm type field, fixed length character field
+ void setAuthLen(uint8_t* text) { memcpy(commitHeader->authlengths, text, ZRTP_WORD_SIZE); };
+
+ /// Set key agreement algorithm type field, fixed length character field
+ void setPubKeyType(uint8_t* text) { memcpy(commitHeader->pubkey, text, ZRTP_WORD_SIZE); };
+
+ /// Set SAS algorithm type field, fixed length character field
+ void setSasType(uint8_t* text) { memcpy(commitHeader->sas, text, ZRTP_WORD_SIZE); };
+
+ /// Set ZID field, a fixed length byte array
+ void setZid(uint8_t* text) { memcpy(commitHeader->zid, text, sizeof(commitHeader->zid)); };
+
+ /// Set HVI field, a fixed length byte array
+ void setHvi(uint8_t* text) { memcpy(commitHeader->hvi, text, sizeof(commitHeader->hvi)); };
+
+ /// Set conce field, a fixed length byte array, overlapping HVI field
+ void setNonce(uint8_t* text);
+
+ /// Set hashH2 field, a fixed length byte array
+ void setH2(uint8_t* hash) { memcpy(commitHeader->hashH2, hash, sizeof(commitHeader->hashH2)); };
+
+ /// Set MAC field, a fixed length byte array
+ void setHMAC(uint8_t* hash) { memcpy(commitHeader->hmac, hash, sizeof(commitHeader->hmac)); };
+
+ /// Set MAC field during multi-stream mode, a fixed length byte array
+ void setHMACMulti(uint8_t* hash) { memcpy(commitHeader->hmac-4*ZRTP_WORD_SIZE, hash, sizeof(commitHeader->hmac)); };
+
+ private:
+ CommitPacket_t data;
+};
+
+/**
+ * @}
+ */
+#endif // ZRTPPACKETCOMMIT
+
diff --git a/src/libzrtpcpp/ZrtpPacketConf2Ack.h b/src/libzrtpcpp/ZrtpPacketConf2Ack.h
new file mode 100644
index 0000000..a7c2567
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpPacketConf2Ack.h
@@ -0,0 +1,60 @@
+/*
+ Copyright (C) 2006-2007 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 _ZRTPPACKETCON2FACK_H_
+#define _ZRTPPACKETCON2FACK_H_
+
+/**
+ * @file ZrtpPacketConf2Ack.h
+ * @brief The ZRTP Conf2Ack message
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <libzrtpcpp/ZrtpPacketBase.h>
+
+/**
+ * Implement the Conf2Ack packet.
+ *
+ * The ZRTP simple message Conf2Ack. The implementation sends this
+ * after receiving and checking the Confirm2 message.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+class __EXPORT ZrtpPacketConf2Ack : public ZrtpPacketBase {
+
+ public:
+ /// Creates a Conf2Ack packet with default data
+ ZrtpPacketConf2Ack();
+
+ ///Creates a Conf2Ack packet from received data
+ ZrtpPacketConf2Ack(char* data);
+
+ /// Normal destructor
+ virtual ~ZrtpPacketConf2Ack();
+
+ private:
+ Conf2AckPacket_t data;
+};
+
+/**
+ * @}
+ */
+#endif // ZRTPPACKETCONF2ACK
+
diff --git a/src/libzrtpcpp/ZrtpPacketConfirm.h b/src/libzrtpcpp/ZrtpPacketConfirm.h
new file mode 100644
index 0000000..b2dfbf4
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpPacketConfirm.h
@@ -0,0 +1,125 @@
+/*
+ Copyright (C) 2006-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 _ZRTPPACKETCONFIRM_H_
+#define _ZRTPPACKETCONFIRM_H_
+
+/**
+ * @file ZrtpPacketConfirm.h
+ * @brief The ZRTP Confirm message
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <libzrtpcpp/ZrtpPacketBase.h>
+
+/**
+ * Implement the Confirm packet.
+ *
+ * The ZRTP message Confirm. The implementation sends this
+ * to confirm the switch to SRTP (encrypted) mode. The contents of
+ * the Confirm message are encrypted, thus the implementation
+ * can check if the secret keys work.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+class __EXPORT ZrtpPacketConfirm : public ZrtpPacketBase {
+
+ private:
+ Confirm_t* confirmHeader; ///< Point to the Confirm message part
+
+ public:
+ /// Creates a Confirm packet with default data
+ ZrtpPacketConfirm();
+
+ /// Creates a Confirm packet with default data and a given signature length
+ ZrtpPacketConfirm(uint32_t sl);
+
+ /// Creates a Confirm packet from received data
+ ZrtpPacketConfirm(uint8_t* d);
+
+ /// Normal destructor
+ virtual ~ZrtpPacketConfirm();
+
+ /// Check if SAS verify flag is set
+ const bool isSASFlag() { return confirmHeader->flags & 0x4; }
+
+ /// Check if PBXEnrollment flag is set
+ const bool isPBXEnrollment() { return confirmHeader->flags & 0x8; }
+
+ /// Get pointer to filler bytes (contains one bit of signature length)
+ const uint8_t* getFiller() { return confirmHeader->filler; }
+
+ /// Get pointer to IV data, fixed byte array
+ const uint8_t* getIv() { return confirmHeader->iv; }
+
+ /// Get pointer to MAC data, fixed byte array
+ const uint8_t* getHmac() { return confirmHeader->hmac; }
+
+ /// Get Expiration time data
+ const uint32_t getExpTime() { return ntohl(confirmHeader->expTime); }
+
+ /// Get pointer to initial hash chain (H0) data, fixed byte array
+ uint8_t* getHashH0() { return confirmHeader->hashH0; }
+
+ /// Get pointer to signature data, variable length, refer to getSignatureLength()
+ const uint8_t* getSignatureData() { return ((uint8_t*)&confirmHeader->expTime) + 4; }
+
+ /// get the signature length in words
+ int32_t getSignatureLength();
+
+ /// set SAS verified flag
+ void setSASFlag() { confirmHeader->flags |= 0x4; }
+
+ /// set setPBXEnrollment flag
+ void setPBXEnrollment() { confirmHeader->flags |= 0x8; }
+
+ /// Set MAC data, fixed length byte array
+ void setHmac(uint8_t* text) { memcpy(confirmHeader->hmac, text, sizeof(confirmHeader->hmac)); }
+
+ /// Set IV data, fixed length byte array
+ void setIv(uint8_t* text) { memcpy(confirmHeader->iv, text, sizeof(confirmHeader->iv)); }
+
+ /// Set expiration time data
+ void setExpTime(uint32_t t) { confirmHeader->expTime = htonl(t); }
+
+ /// Set initial hash chain (H0) data, fixed length byte array
+ void setHashH0(uint8_t* t) { memcpy(confirmHeader->hashH0, t, sizeof(confirmHeader->hashH0)); }
+
+ /// Set signature data, length of the signature data in bytes and must be a multiple of 4.
+ bool setSignatureData(uint8_t* data, int32_t length);
+
+ /// Set signature length in words
+ bool setSignatureLength(uint32_t sl);
+
+ private:
+ void initialize();
+ // Confirm packet is of variable length. It maximum size is 524 words:
+ // - 11 words fixed size
+ // - up to 513 words variable part, depending if signature is present and its length.
+ // This leads to a maximum of 4*524=2096 bytes.
+ uint8_t data[2100]; // large enough to hold a full blown Confirm packet
+
+};
+
+/**
+ * @}
+ */
+#endif // ZRTPPACKETCONFIRM
+
diff --git a/src/libzrtpcpp/ZrtpPacketDHPart.h b/src/libzrtpcpp/ZrtpPacketDHPart.h
new file mode 100644
index 0000000..d0ea4ba
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpPacketDHPart.h
@@ -0,0 +1,120 @@
+/*
+ Copyright (C) 2006-2007 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 _ZRTPPACKETDHPART_H_
+#define _ZRTPPACKETDHPART_H_
+
+/**
+ * @file ZrtpPacketDHPart.h
+ * @brief The ZRTP DHPart message
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <libzrtpcpp/ZrtpPacketBase.h>
+
+/**
+ * Implement the DHPart packet.
+ *
+ * The ZRTP message DHPart. The implementation sends this
+ * to exchange the Diffie-Helman public keys and the shared
+ * secrets between the two parties.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+class __EXPORT ZrtpPacketDHPart : public ZrtpPacketBase {
+
+ protected:
+ uint8_t *pv; ///< points to public key value inside DH message
+ DHPart_t* DHPartHeader; ///< points to DH message structure
+ int32_t dhLength; ///< length of DH message, DH message has variable length
+
+ public:
+ /// Creates a DHPart packet no data, must use setPubKeyType(...)
+ ZrtpPacketDHPart();
+
+ /// Creates a DHPart packet with default data and a give public key type
+ ZrtpPacketDHPart(const char* pkt);
+
+ /// Creates a DHPart packet from received data
+ ZrtpPacketDHPart(uint8_t* data);
+
+ /// Standard destructor
+ virtual ~ZrtpPacketDHPart();
+
+ /// Get pointer to public key value, variable length byte array
+ uint8_t* getPv() { return pv; }
+
+ /// Get pointer to first retained secretd id, fixed length byte array
+ uint8_t* getRs1Id() { return DHPartHeader->rs1Id; };
+
+ /// Get pointer to second retained secretd id, fixed length byte array
+ uint8_t* getRs2Id() { return DHPartHeader->rs2Id; };
+
+ /// Get pointer to additional retained secretd id, fixed length byte array
+ uint8_t* getAuxSecretId() { return DHPartHeader->auxSecretId; };
+
+ /// Get pointer to PBX retained secretd id, fixed length byte array
+ uint8_t* getPbxSecretId() { return DHPartHeader->pbxSecretId; };
+
+ /// Get pointer to first hash (H1) for hash chain, fixed length byte array
+ uint8_t* getH1() { return DHPartHeader->hashH1; };
+
+ /// Get pointer to HMAC, fixed length byte array
+ uint8_t* getHMAC() { return pv+dhLength; };
+
+ /// Setpublic key value, variable length byte array
+ void setPv(uint8_t* text) { memcpy(pv, text, dhLength); };
+
+ /// Set first retained secretd id, fixed length byte array
+ void setRs1Id(uint8_t* text) { memcpy(DHPartHeader->rs1Id, text, sizeof(DHPartHeader->rs1Id)); };
+
+ /// Set second retained secretd id, fixed length byte array
+ void setRs2Id(uint8_t* text) { memcpy(DHPartHeader->rs2Id, text, sizeof(DHPartHeader->rs2Id)); };
+
+ /// Set additional retained secretd id, fixed length byte array
+ void setAuxSecretId(uint8_t* t) { memcpy(DHPartHeader->auxSecretId, t, sizeof(DHPartHeader->auxSecretId)); };
+
+ /// Set PBX retained secretd id, fixed length byte array
+ void setPbxSecretId(uint8_t* t) { memcpy(DHPartHeader->pbxSecretId,t, sizeof(DHPartHeader->pbxSecretId)); };
+
+ /// Set first hash (H1) of hash chain, fixed length byte array
+ void setH1(uint8_t* t) { memcpy(DHPartHeader->hashH1, t, sizeof(DHPartHeader->hashH1)); };
+
+ /// Set key agreement type, fixed size character array
+ void setPubKeyType(const char* pkt);
+
+ /// Set first MAC, fixed length byte array
+ void setHMAC(uint8_t* t) { memcpy(pv+dhLength, t, 2*ZRTP_WORD_SIZE); };
+
+ private:
+ void initialize();
+ // SupportedPubKeys pktype;
+ // DHPart packet is of variable length. It maximum size is 141 words:
+ // - 13 words fixed sizze
+ // - up to 128 words variable part, depending on DH algorithm
+ // leads to a maximum of 4*141=564 bytes.
+ uint8_t data[768]; // large enough to hold a full blown DHPart packet
+};
+
+/**
+ * @}
+ */
+#endif // ZRTPPACKETDHPART
+
diff --git a/src/libzrtpcpp/ZrtpPacketError.h b/src/libzrtpcpp/ZrtpPacketError.h
new file mode 100644
index 0000000..d775801
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpPacketError.h
@@ -0,0 +1,68 @@
+/*
+ Copyright (C) 2006-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 _ZRTPPACKETERROR_H_
+#define _ZRTPPACKETERROR_H_
+
+/**
+ * @file ZrtpPacketError.h
+ * @brief The ZRTP Error message
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <libzrtpcpp/ZrtpPacketBase.h>
+
+/**
+ * Implement the Error packet.
+ *
+ * The ZRTP simple message Error. The implementation sends this
+ * after detecting an error.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+class __EXPORT ZrtpPacketError : public ZrtpPacketBase {
+
+ protected:
+ Error_t* errorHeader; ///< Points to Error message
+
+ public:
+ /// Creates a Error packet with default data
+ ZrtpPacketError();
+
+ /// Creates a Error packet from received data
+ ZrtpPacketError(uint8_t* data);
+
+ virtual ~ZrtpPacketError();
+
+ /// Get the error code from Error message
+ uint32_t getErrorCode() { return ntohl(errorHeader->errorCode); };
+
+ /// Set error code in Error message
+ void setErrorCode(uint32_t code) {errorHeader->errorCode = htonl(code); };
+
+ private:
+ ErrorPacket_t data;
+};
+
+/**
+ * @}
+ */
+#endif // ZRTPPACKETERROR
+
diff --git a/src/libzrtpcpp/ZrtpPacketErrorAck.h b/src/libzrtpcpp/ZrtpPacketErrorAck.h
new file mode 100644
index 0000000..e64c8a6
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpPacketErrorAck.h
@@ -0,0 +1,56 @@
+/*
+ Copyright (C) 2007 - 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 _ZRTPPACKETERRORACK_H_
+#define _ZRTPPACKETERRORACK_H_
+
+/**
+ * @file ZrtpPacketErrorAck.h
+ * @brief The ZRTP ErrorAck message
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <libzrtpcpp/ZrtpPacketBase.h>
+
+/**
+ * Implement the ErrorAck packet.
+ *
+ * The ZRTP simple message ErrorAck. The implementation sends this
+ * after receiving and checking the Error message.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+class __EXPORT ZrtpPacketErrorAck : public ZrtpPacketBase {
+
+ public:
+ /// Creates a ErrorAck packet with default data
+ ZrtpPacketErrorAck();
+
+ /// Creates a ErrorAck packet from received data
+ ZrtpPacketErrorAck(uint8_t* data);
+ virtual ~ZrtpPacketErrorAck();
+
+ private:
+ ErrorAckPacket_t data;
+};
+
+/**
+ * @}
+ */
+#endif // _ZRTPPACKETERRORACK_H_
diff --git a/src/libzrtpcpp/ZrtpPacketGoClear.h b/src/libzrtpcpp/ZrtpPacketGoClear.h
new file mode 100644
index 0000000..10c3be6
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpPacketGoClear.h
@@ -0,0 +1,72 @@
+/*
+ Copyright (C) 2006-2007 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 _ZRTPPACKETGOCLEAR_H_
+#define _ZRTPPACKETGOCLEAR_H_
+
+/**
+ * @file ZrtpPacketGoClear.h
+ * @brief The ZRTP GoClear message
+ *
+ * GNU ZRTP does not implement GoClear feature
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <libzrtpcpp/ZrtpPacketBase.h>
+
+/**
+ * Implement the GoClear packet.
+ *
+ * The ZRTP message GoClear. The implementation sends this
+ * to order the peer to switch to clear mode (non-SRTP mode).
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+class __EXPORT ZrtpPacketGoClear : public ZrtpPacketBase {
+
+ protected:
+ GoClear_t* clearHeader;
+
+ public:
+ /// Creates a GoCLear packet with default data
+ ZrtpPacketGoClear();
+
+ /// Creates a GoClear packet from received data
+ ZrtpPacketGoClear(uint8_t* data);
+
+ virtual ~ZrtpPacketGoClear();
+
+ /// Not used
+ const uint8_t* getClearHmac() { return clearHeader->clearHmac; };
+
+ /// Not used
+ void setClearHmac(uint8_t *text) { memcpy(clearHeader->clearHmac, text, 32); };
+
+ /// Not used
+ void clrClearHmac() { memset(clearHeader->clearHmac, 0, 32); };
+
+ private:
+ GoClearPacket_t data;
+};
+
+/**
+ * @}
+ */
+#endif // ZRTPPACKETGOCLEAR
+
diff --git a/src/libzrtpcpp/ZrtpPacketHello.h b/src/libzrtpcpp/ZrtpPacketHello.h
new file mode 100644
index 0000000..0cc7403
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpPacketHello.h
@@ -0,0 +1,191 @@
+/*
+ Copyright (C) 2006-2007 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 _ZRTPPACKETHELLO_H_
+#define _ZRTPPACKETHELLO_H_
+
+/**
+ * @file ZrtpPacketHello.h
+ * @brief The ZRTP Hello message
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <libzrtpcpp/ZrtpPacketBase.h>
+
+/**
+ * Implement the Hello packet.
+ *
+ * The ZRTP Hello message. The implementation sends this
+ * to start the ZRTP negotiation sequence. The Hello message
+ * offers crypto methods and parameters to the other party. The
+ * other party selects methods and parameters it can support
+ * and uses the Commit message to commit these.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+class __EXPORT ZrtpPacketHello : public ZrtpPacketBase {
+
+ protected:
+ Hello_t* helloHeader; ///< Point to the Hello message part
+
+ int32_t nHash, ///< number of hash algorithms offered
+ nCipher, ///< number of cipher algorithms offered
+ nPubkey, ///< number of key agreement algorithms offered
+ nSas, ///< number of SAS algorithms offered
+ nAuth; ///< number of SRTP authentication algorithms offered
+
+ int32_t oHash, ///< offsets in bytes to hash algorithm names
+ oCipher, ///< offsets in bytes to cipher algorithm names
+ oPubkey, ///< offsets in bytes to key agreement algorithm names
+ oSas, ///< offsets in bytes to SAS algorithm names
+ oAuth, ///< offsets in bytes to SRTP authentication algorithm names
+ oHmac; ///< offsets in bytes to MAC of Hello message
+
+ public:
+ /// Creates a Hello packet with default data
+ ZrtpPacketHello();
+
+ /// Creates a Hello packet from received data
+ ZrtpPacketHello(uint8_t *data);
+
+ virtual ~ZrtpPacketHello();
+
+ /**
+ * Set configure data and populate Hello message data.
+ *
+ * Fill in the offered Algorithm names and compute all offset to
+ * names and MAC. An application must call this method on Hello message
+ * objects created with the standard constructor (with default data)
+ * before the application can use most of the getter and setter methods.
+ *
+ * @param config
+ * Pointer to ZrtpConfigure data.
+ */
+ void configureHello(ZrtpConfigure* config);
+
+ /// Get version number from Hello message, fixed ASCII character array
+ uint8_t* getVersion() { return helloHeader->version; };
+
+ /// Get client id from Hello message, fixed ASCII character array
+ uint8_t* getClientId() { return helloHeader->clientId; };
+
+ /// Get H3 hash from Hello message, fixed byte array
+ uint8_t* getH3() { return helloHeader->hashH3; };
+
+ /// Get client ZID from Hello message, fixed bytes array
+ uint8_t* getZid() { return helloHeader->zid; };
+
+ /// Set version sting in Hello message, fixed ASCII character array
+ void setVersion(uint8_t *text) { memcpy(helloHeader->version, text,ZRTP_WORD_SIZE ); }
+
+ /// Set client id in Hello message, fixed ASCII character array
+ void setClientId(const uint8_t *t) { memcpy(helloHeader->clientId, t, sizeof(helloHeader->clientId)); }
+
+ /// Set H3 hash in Hello message, fixed byte array
+ void setH3(uint8_t *hash) { memcpy(helloHeader->hashH3, hash, sizeof(helloHeader->hashH3)); }
+
+ /// Set client ZID in Hello message, fixed bytes array
+ void setZid(uint8_t *text) { memcpy(helloHeader->zid, text, sizeof(helloHeader->zid)); }
+
+ /// Check passive mode (mode not implemented)
+ bool isPassive() { return helloHeader->flags & 0x10; };
+
+ /// Check if MitM flag is set
+ bool isMitmMode() { return helloHeader->flags & 0x20; };
+
+ /// Check if SAS sign flag is set
+ bool isSasSign() { return helloHeader->flags & 0x40; };
+
+ /// Get hash algorithm name at position n, fixed ASCII character array
+ uint8_t* getHashType(int32_t n) { return ((uint8_t*)helloHeader)+oHash+(n*ZRTP_WORD_SIZE); }
+
+ /// Get ciper algorithm name at position n, fixed ASCII character array
+ uint8_t* getCipherType(int32_t n) { return ((uint8_t*)helloHeader)+oCipher+(n*ZRTP_WORD_SIZE); }
+
+ /// Get SRTP authentication algorithm name at position n, fixed ASCII character array
+ uint8_t* getAuthLen(int32_t n) { return ((uint8_t*)helloHeader)+oAuth+(n*ZRTP_WORD_SIZE); }
+
+ /// Get key agreement algorithm name at position n, fixed ASCII character array
+ uint8_t* getPubKeyType(int32_t n) { return ((uint8_t*)helloHeader)+oPubkey+(n*ZRTP_WORD_SIZE); }
+
+ /// Get SAS algorithm name at position n, fixed ASCII character array
+ uint8_t* getSasType(int32_t n) { return ((uint8_t*)helloHeader)+oSas+(n*ZRTP_WORD_SIZE); }
+
+ /// Get Hello MAC, fixed byte array
+ uint8_t* getHMAC() { return ((uint8_t*)helloHeader)+oHmac; }
+
+ /// Set hash algorithm name at position n, fixed ASCII character array
+ void setHashType(int32_t n, int8_t* t)
+ { memcpy(((uint8_t*)helloHeader)+oHash+(n*ZRTP_WORD_SIZE), t, ZRTP_WORD_SIZE); }
+
+ /// Set ciper algorithm name at position n, fixed ASCII character array
+ void setCipherType(int32_t n, int8_t* t)
+ { memcpy(((uint8_t*)helloHeader)+oCipher+(n*ZRTP_WORD_SIZE), t, ZRTP_WORD_SIZE); }
+
+ /// Set SRTP authentication algorithm name at position n, fixed ASCII character array
+ void setAuthLen(int32_t n, int8_t* t)
+ { memcpy(((uint8_t*)helloHeader)+oAuth+(n*ZRTP_WORD_SIZE), t, ZRTP_WORD_SIZE); }
+
+ /// Set key agreement algorithm name at position n, fixed ASCII character array
+ void setPubKeyType(int32_t n, int8_t* t)
+ { memcpy(((uint8_t*)helloHeader)+oPubkey+(n*ZRTP_WORD_SIZE), t, ZRTP_WORD_SIZE); }
+
+ /// Set SAS algorithm name at position n, fixed ASCII character array
+ void setSasType(int32_t n, int8_t* t)
+ { memcpy(((uint8_t*)helloHeader)+oSas+(n*ZRTP_WORD_SIZE), t, ZRTP_WORD_SIZE); }
+
+ /// Set Hello MAC, fixed byte array
+ void setHMAC(uint8_t* t)
+ { memcpy(((uint8_t*)helloHeader)+oHmac, t, 2*ZRTP_WORD_SIZE); }
+
+ /// Get number of offered hash algorithms
+ int32_t getNumHashes() {return nHash; }
+
+ /// Get number of offered cipher algorithms
+ int32_t getNumCiphers() {return nCipher; }
+
+ /// Get number of offered key agreement algorithms
+ int32_t getNumPubKeys() {return nPubkey; }
+
+ /// Get number of offered SAS algorithms
+ int32_t getNumSas() {return nSas; }
+
+ /// Get number of offered SRTP authentication algorithms
+ int32_t getNumAuth() {return nAuth; }
+
+ /// set MitM flag
+ void setMitmMode() { helloHeader->flags |= 0x20; }
+
+ /// set SAS sign flag
+ void setSasSign() { helloHeader->flags |= 0x40; }
+
+ private:
+ // Hello packet is of variable length. It maximum size is 46 words:
+ // - 11 words fixed sizze
+ // - up to 35 words variable part, depending on number of algorithms
+ // leads to a maximum of 4*46=184 bytes.
+ uint8_t data[256]; // large enough to hold a full blown Hello packet
+};
+
+/**
+ * @}
+ */
+#endif // ZRTPPACKETHELLO
+
diff --git a/src/libzrtpcpp/ZrtpPacketHelloAck.h b/src/libzrtpcpp/ZrtpPacketHelloAck.h
new file mode 100644
index 0000000..345a071
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpPacketHelloAck.h
@@ -0,0 +1,59 @@
+/*
+ Copyright (C) 2006-2007 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 _ZRTPPACKETHELLOACK_H_
+#define _ZRTPPACKETHELLOACK_H_
+
+/**
+ * @file ZrtpPacketHelloAck.h
+ * @brief The ZRTP HelloAck message
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <libzrtpcpp/ZrtpPacketBase.h>
+
+/**
+ * Implement the HelloAck packet.
+ *
+ * The ZRTP simple message HelloAck. The implementation sends this
+ * after receiving a Hello packet.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+class __EXPORT ZrtpPacketHelloAck : public ZrtpPacketBase {
+
+ public:
+ /// Creates a HelloAck packet with default data
+ ZrtpPacketHelloAck();
+
+ /// Creates a HelloAck packet from received data
+ ZrtpPacketHelloAck(uint8_t* data);
+
+ virtual ~ZrtpPacketHelloAck();
+
+ private:
+ HelloAckPacket_t data;
+};
+
+/**
+ * @}
+ */
+#endif // ZRTPPACKETHELLOACK
+
diff --git a/src/libzrtpcpp/ZrtpPacketPing.h b/src/libzrtpcpp/ZrtpPacketPing.h
new file mode 100644
index 0000000..840df62
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpPacketPing.h
@@ -0,0 +1,67 @@
+/*
+ Copyright (C) 2006-2009 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 _ZRTPPACKETPING_H_
+#define _ZRTPPACKETPING_H_
+
+/**
+ * @file ZrtpPacketPing.h
+ * @brief The ZRTP Ping message
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <libzrtpcpp/ZrtpPacketBase.h>
+
+/**
+ * Implement the PingAck packet.
+ *
+ * The ZRTP simple message PingAck.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+class __EXPORT ZrtpPacketPing : public ZrtpPacketBase {
+
+ protected:
+ Ping_t* pingHeader; ///< Point the the Ping message
+
+ public:
+ /// Creates a Ping message with default data
+ ZrtpPacketPing();
+
+ /// Creates a Ping message from received data
+ ZrtpPacketPing(uint8_t* data);
+
+ virtual ~ZrtpPacketPing();
+
+ /// Set ZRTP protocol version field, fixed ASCII character array
+ void setVersion(uint8_t *text) { memcpy(pingHeader->version, text,ZRTP_WORD_SIZE ); }
+
+ /// Get the endpoit hash, fixed byte array
+ uint8_t* getEpHash() { return pingHeader->epHash; }
+
+ private:
+ PingPacket_t data;
+};
+
+/**
+ * @}
+ */
+
+#endif // ZRTPPACKETCLEARACK
+
diff --git a/src/libzrtpcpp/ZrtpPacketPingAck.h b/src/libzrtpcpp/ZrtpPacketPingAck.h
new file mode 100644
index 0000000..51ad8c8
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpPacketPingAck.h
@@ -0,0 +1,74 @@
+/*
+ Copyright (C) 2006-2009 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 _ZRTPPACKETPINGACK_H_
+#define _ZRTPPACKETPINGACK_H_
+
+#include <libzrtpcpp/ZrtpPacketBase.h>
+/**
+ * @file ZrtpPacketPingAck.h
+ * @brief The ZRTP PingAck message
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+/**
+ * Implement the PingAck packet.
+ *
+ * The ZRTP simple message PingAck.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+class __EXPORT ZrtpPacketPingAck : public ZrtpPacketBase {
+
+ protected:
+ PingAck_t* pingAckHeader; ///< Points to PingAck message
+
+ public:
+ /// Creates a PingAck message with default data
+ ZrtpPacketPingAck();
+
+ /// Creates a PingAck message from received data
+ ZrtpPacketPingAck(uint8_t* data);
+
+ virtual ~ZrtpPacketPingAck();
+
+ /// Get SSRC from PingAck message
+ uint32_t getSSRC() { return ntohl(pingAckHeader->ssrc); };
+
+ /// Set ZRTP protocol version field, fixed ASCII character array
+ void setVersion(uint8_t *text) { memcpy(pingAckHeader->version, text, ZRTP_WORD_SIZE ); }
+
+ /// Set SSRC in PingAck message
+ void setSSRC(uint32_t data) {pingAckHeader->ssrc = htonl(data); };
+
+ /// Set remote endpoint hash, fixed byte array
+ void setRemoteEpHash(uint8_t *hash) { memcpy(pingAckHeader->remoteEpHash, hash, sizeof(pingAckHeader->remoteEpHash)); }
+
+ /// Set local endpoint hash, fixed byte array
+ void setLocalEpHash(uint8_t *hash) { memcpy(pingAckHeader->localEpHash, hash, sizeof(pingAckHeader->localEpHash)); }
+
+ private:
+ PingAckPacket_t data;
+};
+
+/**
+ * @}
+ */
+#endif // ZRTPPACKETCLEARACK
+
diff --git a/src/libzrtpcpp/ZrtpPacketRelayAck.h b/src/libzrtpcpp/ZrtpPacketRelayAck.h
new file mode 100644
index 0000000..93437e6
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpPacketRelayAck.h
@@ -0,0 +1,56 @@
+/*
+ Copyright (C) 2007 - 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 _ZRTPPACKETRELAYACK_H_
+#define _ZRTPPACKETRELAYACK_H_
+
+/**
+ * @file ZrtpPacketRelayAck.h
+ * @brief The ZRTP RelayAck message
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <libzrtpcpp/ZrtpPacketBase.h>
+
+/**
+ * Implement the RelayAck packet.
+ *
+ * The ZRTP simple message RelayAck. The implementation sends this
+ * after receiving and checking the SASrelay message.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+class __EXPORT ZrtpPacketRelayAck : public ZrtpPacketBase {
+
+ public:
+ /// Creates a RelayAck packet with default data
+ ZrtpPacketRelayAck();
+
+ /// Creates a RelayAck packet from received data
+ ZrtpPacketRelayAck(uint8_t* data);
+ virtual ~ZrtpPacketRelayAck();
+
+ private:
+ RelayAckPacket_t data;
+};
+
+/**
+ * @}
+ */
+#endif // _ZRTPPACKETRELAYACK_H_
diff --git a/src/libzrtpcpp/ZrtpPacketSASrelay.h b/src/libzrtpcpp/ZrtpPacketSASrelay.h
new file mode 100644
index 0000000..427ac28
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpPacketSASrelay.h
@@ -0,0 +1,113 @@
+/*
+ Copyright (C) 2006-2011 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 _ZRTPPACKETSASRELAY_H_
+#define _ZRTPPACKETSASRELAY_H_
+
+/**
+ * @file ZrtpPacketSASrelay.h
+ * @brief The ZRTP SAS Relay message
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <libzrtpcpp/ZrtpPacketBase.h>
+
+/**
+ * Implement the Confirm packet.
+ *
+ * The ZRTP message Confirm. The implementation sends this
+ * to confirm the switch to SRTP (encrypted) mode. The contents of
+ * the Confirm message are encrypted, thus the implementation
+ * can check if the secret keys work.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+class __EXPORT ZrtpPacketSASrelay : public ZrtpPacketBase {
+
+ private:
+ SASrelay_t* sasRelayHeader; ///< Point to the Confirm message part
+
+ public:
+ /// Creates a Confirm packet with default data
+ ZrtpPacketSASrelay();
+
+ /// Creates a Confirm packet with default data and a given signature length
+ ZrtpPacketSASrelay(uint32_t sl);
+
+ /// Creates a Confirm packet from received data
+ ZrtpPacketSASrelay(uint8_t* d);
+
+ /// Normal destructor
+ virtual ~ZrtpPacketSASrelay();
+
+ /// Check is SAS verify flag is set
+ const bool isSASFlag() { return sasRelayHeader->flags & 0x4; }
+
+ /// Get pointer to filler bytes (contains one bit of signature length)
+ const uint8_t* getFiller() { return sasRelayHeader->filler; }
+
+ /// Get pointer to IV data, fixed byte array
+ const uint8_t* getIv() { return sasRelayHeader->iv; }
+
+ /// Get pointer to MAC data, fixed byte array
+ const uint8_t* getHmac() { return sasRelayHeader->hmac; }
+
+ /// Get pointer to new SAS rendering algorithm, fixed byte array
+ const uint8_t* getSas() {return sasRelayHeader->sas; }
+
+ /// Get pointer to new SAS hash data, fixed byte array
+ const uint8_t* getTrustedSas() { return sasRelayHeader->trustedSasHash; }
+
+ /// get the signature length in words
+ uint32_t getSignatureLength();
+
+ /// set SAS verified flag
+ void setSASFlag() { sasRelayHeader->flags |= 0x4; }
+
+ /// Set MAC data, fixed length byte array
+ void setHmac(uint8_t* text) { memcpy(sasRelayHeader->hmac, text, sizeof(sasRelayHeader->hmac)); }
+
+ /// Set IV data, fixed length byte array
+ void setIv(uint8_t* text) { memcpy(sasRelayHeader->iv, text, sizeof(sasRelayHeader->iv)); }
+
+ /// Set SAS rendering algorithm, fixed length byte array
+ void setSas(uint8_t* text) { memcpy(sasRelayHeader->sas, text, sizeof(sasRelayHeader->sas)); }
+
+ /// Set SAS hash data, fixed length byte array
+ void setTrustedSas(uint8_t* text) { memcpy(sasRelayHeader->trustedSasHash, text, sizeof(sasRelayHeader->trustedSasHash)); }
+
+ /// Set signature length in words
+ void setSignatureLength(uint32_t sl);
+
+ private:
+ void initialize();
+ // Confirm packet is of variable length. It maximum size is 524 words:
+ // - 11 words fixed size
+ // - up to 513 words variable part, depending if signature is present and its length.
+ // This leads to a maximum of 4*524=2096 bytes.
+ uint8_t data[2100]; // large enough to hold a full blown Confirm packet
+
+};
+
+/**
+ * @}
+ */
+#endif // ZRTPPACKETSASRELAY
+
diff --git a/src/libzrtpcpp/ZrtpQueue.h b/src/libzrtpcpp/ZrtpQueue.h
new file mode 100644
index 0000000..0454771
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpQueue.h
@@ -0,0 +1,917 @@
+/*
+ Copyright (C) 2006-2009 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 _ZRTPQUEUE_H_
+#define _ZRTPQUEUE_H_
+
+#include <ccrtp/cqueue.h>
+#include <ccrtp/rtppkt.h>
+#include <libzrtpcpp/ZrtpCallback.h>
+#include <libzrtpcpp/TimeoutProvider.h>
+#include <libzrtpcpp/ZrtpConfigure.h>
+
+class __EXPORT ZrtpUserCallback;
+class __EXPORT ZRtp;
+
+NAMESPACE_COMMONCPP
+
+/**
+ * GNU ccRTP extension to support GNU ZRTP.
+ *
+ * ZRTP was developed by Phil Zimmermann and provides functions to
+ * negotiate keys and other necessary data (crypto data) to set-up
+ * the Secure RTP (SRTP) crypto context. Refer to Phil's ZRTP
+ * specification at his <a href="http://zfoneproject.com/">Zfone
+ * project</a> site to get more detailed imformation about the
+ * capabilities of ZRTP.
+ *
+ * <b>Short overview of the ZRTP implementation</b>
+ *
+ * ZRTP is a specific protocol to negotiate encryption algorithms
+ * and the required key material. ZRTP uses a RTP session to
+ * exchange its protocol messages.
+ *
+ * A complete GNU ZRTP implementation consists of two parts, the
+ * GNU ZRTP core and specific code that binds the GNU ZRTP core to
+ * the underlying RTP/SRTP stack and the operating system:
+ * <ul>
+ * <li>
+ * The GNU ZRTP core is independent of a specific RTP/SRTP
+ * stack and the operationg system and consists of the ZRTP
+ * protocol state engine, the ZRTP protocol messages, and the
+ * GNU ZRTP engine. The GNU ZRTP engine provides methods to
+ * setup ZRTP message and to analyze received ZRTP messages,
+ * to compute the crypto data required for SRTP, and to
+ * maintain the required hashes and HMAC.
+ * </li>
+ * <li>
+ * The second part of an implementation is specific
+ * <em>glue</em> code the binds the GNU ZRTP core to the
+ * actual RTP/SRTP implementation and other operating system
+ * specific services such as timers.
+ * </li>
+ * </ul>
+ *
+ * The GNU ZRTP core uses a callback interface class (refer to
+ * ZrtpCallback) to access RTP/SRTP or operating specific methods,
+ * for example to send data via the RTP/SRTP stack, to access
+ * timers, provide mutex handling, and to report events to the
+ * application.
+ *
+ * <b>The ZrtpQueue</b>
+ *
+ * ZrtpQueue implements code that is specific to the GNU ccRTP
+ * implementation. ZrtpQueue also implements the specific code to
+ * provide the mutex and timeout handling to the GNU ZRTP
+ * core. Both, the mutex and the timeout handling, use the GNU
+ * Common C++ library to stay independent of the operating
+ * seystem. For more information refer to the <a
+ * href="http://www.gnutelephony.org/index.php/GNU_Common_C%2B%2B">GNU
+ * Common C++</a> web site.
+ *
+ * To perform its tasks ZrtpQueue
+ * <ul>
+ * <li> extends GNU ccRTP classes to use the underlying
+ * ccRTP methods and the RTP/SRTP send and receive queues
+ * </li>
+ * <li> implements the ZrtpCallback interface to provide ccRTP
+ * access and other specific services (timer, mutex) to GNU
+ * ZRTP
+ * </li>
+ * <li> provides ZRTP specific methods that applications may use
+ * to control and setup GNU ZRTP
+ * </li>
+ * <li> can register and use an application specific callback
+ * class (refer to ZrtpUserCallback)
+ * </li>
+ * </ul>
+ *
+ * After instantiating a GNU ZRTP session (see below for a short
+ * example) applications may use the ZRTP specific methods of
+ * ZrtpQueue to control and setup GNU ZRTP, for example enable or
+ * disable ZRTP processing or getting ZRTP status information.
+ *
+ * GNU ZRTP provides a ZrtpUserCallback class that an application
+ * may extend and register with ZrtpQueue. GNU ZRTP and ZrtpQueue
+ * use the ZrtpUserCallback methods to report ZRTP events to the
+ * application. The application may display this information to
+ * the user or act otherwise.
+ *
+ * The following figure depicts the relationships between
+ * ZrtpQueue, ccRTP RTP/SRTP implementation, the GNU ZRTP core,
+ * and an application that provides an ZrtpUserCallback class.
+ *
+@verbatim
+
+ +----------+
+ | ccRTP |
+ | RTP/SRTP |
+ | |
+ +----------+
+ ^
+ | extends
+ |
++----------------+ +-----+------+
+| Application | | | +-----------------+
+| instantiates | uses | ZrtpQueue | uses | |
+| a ZRTP Session +------+ implements +------+ GNU ZRTP |
+| and provides | |ZrtpCallback| | core |
+|ZrtpUserCallback| | | | implementation |
++----------------+ +------------+ | (ZRtp et al) |
+ | |
+ +-----------------+
+@endverbatim
+ *
+ * Because ZrtpQueue extends the ccRTP RTP/SRTP implementation
+ * (AVPQueue) all public methods defined by ccRTP are also
+ * available for a ZRTP session. ZrtpQueue overwrites some of the
+ * public methods of ccRTP (AVPQueue) to implement ZRTP specific
+ * code.
+ *
+ * GNU ZRTP provides a <em>SymmetricZRTPSession</em> type to
+ * simplify its use. An application uses this type in the same way
+ * as it would use the normal ccRTP <em>SymmetricRTPSession</em>
+ * type. The following short code snippets show how an application
+ * could instantiate ccRTP and GNU ZRTP sessions. The first
+ * snippet shows how to instantiate a ccRTP session:
+ *
+ * @code
+ * ...
+ * #include <ccrtp/rtp.h>
+ * ...
+ * SymmetricRTPSession tx(pattern.getSsrc(),
+ * InetHostAddress("localhost"));
+ * ...
+ *
+ * @endcode
+ *
+ * The same code as above but using a GNU ZRTP session this time:
+ * @code
+ * ...
+ * #include <libzrtpcpp/zrtpccrtp.h>
+ * ...
+ * SymmetricZRTPSession tx(pattern.getSsrc(),
+ * InetHostAddress("localhost"));
+ * ...
+ *
+ * @endcode
+ *
+ * The only differences are the different include statements and
+ * the different session types.
+ *
+ * The <em>demo</em> folder contains a small example that shows
+ * how to use GNU ZRTP.
+ *
+ * Please refer to the GNU ccRTP documentation for a description
+ * of ccRTP methods and functions. This ZrtpQueue documentation
+ * shows the ZRTP specific extensions and describes overloaded
+ * methods and a possible different behaviour.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+class __EXPORT ZrtpQueue : public AVPQueue, ZrtpCallback {
+
+public:
+
+ /**
+ * Initialize the ZrtpQueue.
+ *
+ * Before an application can use ZRTP it has to initialize the
+ * ZRTP implementation. This method initializes the timeout
+ * thread and opens a file that contains ZRTP specific
+ * information such as the applications ZID (ZRTP id) and its
+ * retained shared secrets.
+ *
+ * If one application requires several ZRTP sessions all
+ * sessions use the same timeout thread and use the same ZID
+ * file. Therefore an application does not need to do any
+ * synchronisation regading ZID files or timeouts. This is
+ * managed by the ZRTP implementation.
+ *
+ * The current implementation of ZrtpQueue does not support
+ * different ZID files for one application instance. This
+ * restriction may be removed in later versions.
+ *
+ * The application may specify its own ZID file name. If no
+ * ZID file name is specified it defaults to
+ * <code>$HOME/.GNUccRTP.zid</code> if the <code>HOME</code>
+ * environment variable is set. If it is not set the current
+ * directory is used.
+ *
+ * If the method could set up the timeout thread and open the ZID
+ * file then it enables ZRTP processing and returns.
+ *
+ * @param zidFilename
+ * The name of the ZID file, can be a relative or absolut
+ * filename.
+ *
+ * @param autoEnable
+ * if set to true the method automatically sets enableZrtp to
+ * true. This enables the ZRTP auto-sense mode. Default is true.
+ *
+ * @param config
+ * this parameter points to ZRTP configuration data. If it is
+ * NULL then ZrtpQueue uses a default setting. Default is NULL.
+ *
+ * @return
+ * 1 on success, ZRTP processing enabled, -1 on failure,
+ * ZRTP processing disabled.
+ *
+ */
+ int32_t initialize(const char *zidFilename, bool autoEnable = true,
+ ZrtpConfigure* config = NULL);
+
+ /*
+ * Applications use the following methods to control ZRTP, for example
+ * to enable ZRTP, set flags etc.
+ */
+
+ /**
+ * Enable or disable ZRTP processing.
+ *
+ * Call this method to enable or disable ZRTP processing after
+ * calling <code>initialize()</code>. This can be done before
+ * using a RTP session or at any time during a RTP session.
+ *
+ * Existing SRTP sessions or currently active ZRTP processing will
+ * not be stopped or disconnected.
+ *
+ * If the application enables ZRTP then:
+ * <ul>
+ * <li>ZrtpQueue starts to send ZRTP Hello packets after at least
+ * one RTP packet was sent and received on the associated RTP
+ * session. Thus if an application enables ZRTP and ZrtpQueue
+ * detects traffic on the RTP session then ZrtpQueue automatically
+ * starts the ZRTP protocol. This automatic start is convenient
+ * for applications that negotiate RTP parameters and set up RTP
+ * sessions but the actual RTP traffic starts some time later.
+ * </li>
+ * <li>ZrtpQueue analyses incoming packets to detect ZRTP
+ * messages. If ZRTP was started, either via automatic start (see
+ * above) or explicitly via startZrtp(), then ZrtpQueue
+ * forwards ZRTP packets to the GNU ZRTP core.
+ * </ul>
+ *
+ * @param onOff
+ * @c true to enable ZRTP, @c false to disable ZRTP
+ */
+ void setEnableZrtp(bool onOff);
+
+ /**
+ * Return the state of ZRTP enable state.
+ *
+ * @return @c true if ZRTP processing is enabled, @c false
+ * otherwise.
+ */
+ bool isEnableZrtp();
+
+ /**
+ * Set SAS as verified.
+ *
+ * The application may call this method if the user confirmed
+ * (verfied) the Short Authentication String (SAS) with the peer.
+ *
+ * ZRTP calls ZrtpUserCallback#showSAS after it computed the SAS
+ * and the application registered a user callback class. The
+ * application should display the SAS and provide a mechanism at
+ * the user interface that enables the user to confirm the SAS.
+ *
+ * ZRTP remembers the SAS confirmation status together with the
+ * retained secrets data. If both parties confirmed the SAS then
+ * ZRTP informs the application about this status on the next ZRTP
+ * session.
+ *
+ * For more detailed information regarding SAS please refer to the
+ * ZRTP specification, chapter 8.
+ */
+ void SASVerified();
+
+ /**
+ * Reset the SAS verfied flag for the current user's retained secrets.
+ *
+ */
+ void resetSASVerified();
+
+ /**
+ * To confirm a go clear request.
+ *
+ * Call this method if the user confirmed a go clear (secure mode off).
+ */
+ void goClearOk();
+
+ /**
+ * Request to switch off secure mode.
+ *
+ * Call this method is the user itself wants to switch off secure
+ * mode (go clear). After sending the "go clear" request to the peer
+ * ZRTP immediatly switch off SRTP processing. Every RTP data is sent
+ * in clear after the go clear request.
+ */
+ void requestGoClear();
+
+ /**
+ * Set the auxilliary secret.
+ *
+ * Use this method to set the srtps secret data. Refer to ZRTP
+ * specification, chapter 5.3 ff
+ *
+ * @param data
+ * Points to the auxilliary secret data.
+ * @param length
+ * Length of the auxilliary secrect in bytes
+ */
+ void setAuxSecret(uint8_t* data, int32_t length);
+
+ /**
+ * Set the application's callback class.
+ *
+ * The destructor of ZrtpQueue also destorys the user callback
+ * class if it was set. The application must not delete the
+ * callback object or use/reference the callback object after
+ * ZrtpQueue was destroyed.
+ *
+ * @param ucb
+ * Implementation of the application's ZrtpUserCallback class
+ */
+ void setUserCallback(ZrtpUserCallback* ucb);
+
+ /**
+ * Set the client ID for ZRTP Hello message.
+ *
+ * The GNU ccRTP client may set its id to identify itself in the
+ * ZRTP Hello message. The maximum length is 16 characters. A
+ * shorter id string is possible, it will be filled with blanks. A
+ * longer id string will be truncated to 16 characters. The
+ * standard client id is <code>'GNU ccRTP ZRTP '</code> (without
+ * the quotes).
+ *
+ * Setting the client's id must be done before calling
+ * ZrtpQueue#initialize() or ZrtpQueue#startZrtp() .
+ *
+ * @param id
+ * The client's id string
+ */
+ void setClientId(std::string id);
+
+ /**
+ * Get the ZRTP Hello Hash data.
+ *
+ * Use this method to get the ZRTP Hello Hash data. The method
+ * returns the data as a string containing hex-digits. Refer
+ * to ZRTP specification, chapter 9.1.
+ *
+ * @return
+ * a std:string containing the Hello hash value as hex-digits. The
+ * hello hash is available immediatly after calling
+ * ZrtpQueue#startZrtp. If ZRTP was not started the method returns
+ * an empty string.
+ */
+ std::string getHelloHash();
+
+ /**
+ * Get the peer's ZRTP Hello Hash data.
+ *
+ * Use this method to get the peer's ZRTP Hello Hash data. The method
+ * returns the data as a string containing the ZRTP protocol version and
+ * hex-digits.
+ *
+ * The peer's hello hash is available only after ZRTP received a hello. If
+ * no data is available the function returns an empty string.
+ *
+ * Refer to ZRTP specification, chapter 8.
+ *
+ * @return
+ * a std:string containing the Hello version and the hello hash as hex digits.
+ */
+ std::string getPeerHelloHash();
+
+ /**
+ * Get Multi-stream parameters.
+ *
+ * Use this method to get the Multi-stream that were computed during
+ * the ZRTP handshake. An application may use these parameters to
+ * enable multi-stream processing for an associated SRTP session.
+ *
+ * Refer to chapter 5.4.2 in the ZRTP specification for further details
+ * and restriction how and when to use multi-stream mode.
+ *
+ * @return
+ * a string that contains the multi-stream parameters. The application
+ * must not modify the contents of this string, it is opaque data. The
+ * application may hand over this string to a new ZrtpQueue instance
+ * to enable multi-stream processing for this ZrtpQueue. If ZRTP was
+ * not started or ZRTP is not yet in secure state the method returns an
+ * empty string.
+ *
+ * @see setMultiStrParams()
+ */
+ std::string getMultiStrParams();
+
+ /**
+ * Set Multi-stream parameters.
+ *
+ * Use this method to set the parameters required to enable Multi-stream
+ * processing of ZRTP. The multi-stream parameters must be set before the
+ * application starts the ZRTP protocol engine.
+ *
+ * Refer to chapter 5.4.2 in the ZRTP specification for further details
+ * of multi-stream mode.
+ *
+ * @param parameters
+ * A string that contains the multi-stream parameters that this
+ * new ZrtpQueue instanace shall use.
+ *
+ * @see getMultiStrParams()
+ */
+ void setMultiStrParams(std::string parameters);
+
+ /**
+ * Check if this ZRTP use Multi-stream.
+ *
+ * Use this method to check if this ZRTP instance uses multi-stream. Even
+ * if the application provided multi-stram parameters it may happen that
+ * full DH mode was used. Refer to chapters 5.2 and 5.4.2 in the ZRTP #
+ * when this may happen.
+ *
+ * @return
+ * True if multi-stream is used, false otherwise.
+ */
+ bool isMultiStream();
+
+ /**
+ * Check if the other ZRTP client supports Multi-stream.
+ *
+ * Use this method to check if the other ZRTP client supports
+ * Multi-stream mode.
+ *
+ * @return
+ * True if multi-stream is available, false otherwise.
+ */
+ bool isMultiStreamAvailable();
+
+ /**
+ * Accept a PBX enrollment request.
+ *
+ * If a PBX service asks to enroll the MiTM key and the user accepts this
+ * requtes, for example by pressing an OK button, the client application
+ * shall call this method and set the parameter <code>accepted</code> to
+ * true. If the user does not accept the request set the parameter to
+ * false.
+ *
+ * @param accepted
+ * True if the enrollment request is accepted, false otherwise.
+ */
+ void acceptEnrollment(bool accepted);
+
+ /**
+ * Get the commited SAS rendering algorithm for this ZRTP session.
+ *
+ * @return the commited SAS rendering algorithm
+ */
+ std::string getSasType();
+
+ /**
+ * Get the computed SAS hash for this ZRTP session.
+ *
+ * A PBX ZRTP back-to-Back function uses this function to get the SAS
+ * hash of an enrolled client to construct the SAS relay packet for
+ * the other client.
+ *
+ * @return a refernce to the byte array that contains the full
+ * SAS hash.
+ */
+ uint8_t* getSasHash();
+
+ /**
+ * Send the SAS relay packet.
+ *
+ * The method creates and sends a SAS relay packet according to the ZRTP
+ * specifications. Usually only a MitM capable user agent (PBX) uses this
+ * function.
+ *
+ * @param sh the full SAS hash value
+ * @param render the SAS rendering algorithm
+ */
+ bool sendSASRelayPacket(uint8_t* sh, std::string render);
+
+ /**
+ * Check the state of the MitM mode flag.
+ *
+ * If true then this ZRTP session acts as MitM, usually enabled by a PBX
+ * client (user agent)
+ *
+ * @return state of mitmMode
+ */
+ bool isMitmMode();
+
+ /**
+ * Set the state of the MitM mode flag.
+ *
+ * If MitM mode is set to true this ZRTP session acts as MitM, usually
+ * enabled by a PBX client (user agent).
+ *
+ * @param mitmMode defines the new state of the mitmMode flag
+ */
+ void setMitmMode(bool mitmMode);
+
+ /**
+ * Enable or disable paranoid mode.
+ *
+ * The Paranoid mode controls the behaviour and handling of the SAS verify flag. If
+ * Panaoid mode is set to flase then ZRtp applies the normal handling. If Paranoid
+ * mode is set to true then the handling is:
+ *
+ * <ul>
+ * <li> always set the SAS verify flag to <code>false</code> at srtpSecretsOn() callback. The
+ * user interface (UI) must show <b>SAS not verified</b>. See implementation note below.</li>
+ * <li> don't set the SAS verify flag in the <code>Confirm</code> packets, thus forcing the other
+ * peer to report <b>SAS not verified</b>.</li>
+ * <li> ignore the <code>SASVerified()</code> function, thus do not set the SAS verified flag
+ * in the ZRTP cache. </li>
+ * <li> Disable the <em>Trusted PBX MitM</em> feature. Just send the <code>SASRelay</code> packet
+ * but do not process the relayed data. This protects the user from a malicious
+ * "trusted PBX".</li>
+ * </ul>
+ * ZRtp performs alls other steps during the ZRTP negotiations as usual, in particular it
+ * computes, compares, uses, and stores the retained secrets. This avoids unnecessary warning
+ * messages. The user may enable or disable the Paranoid mode on a call-by-call basis without
+ * breaking the key continuity data.
+ *
+ * <b>Implementation note:</b><br/>
+ * An application shall <b>always display the SAS if the SAS verify flag is <code>false</code></b>.
+ * The application shall remind the user to compare the SAS code, for example using larger fonts,
+ * different colours and other display features.
+ */
+ void setParanoidMode(bool yesNo);
+
+ /**
+ * Check status of paranoid mode.
+ *
+ * @return
+ * Returns true if paranoid mode is enabled.
+ */
+ bool isParanoidMode();
+
+ /**
+ * Check the state of the enrollment mode.
+ *
+ * If true then we will set the enrollment flag (E) in the confirm
+ * packets and performs the enrollment actions. A MitM (PBX) enrollment service sets this flagstarted this ZRTP
+ * session. Can be set to true only if mitmMode is also true.
+ * @return status of the enrollmentMode flag.
+ */
+ bool isEnrollmentMode();
+
+ /**
+ * Check the state of the enrollment mode.
+ *
+ * If true then we will set the enrollment flag (E) in the confirm
+ * packets and perform the enrollment actions. A MitM (PBX) enrollment
+ * service must sets this mode to true.
+ *
+ * Can be set to true only if mitmMode is also true.
+ *
+ * @param enrollmentMode defines the new state of the enrollmentMode flag
+ */
+ void setEnrollmentMode(bool enrollmentMode);
+
+ /**
+ * Backwards compatible api fix...
+ */
+ inline void setPBXEnrollment(bool enrollmentMode)
+ {setMitmMode(enrollmentMode); setEnrollmentMode(enrollmentMode);}
+
+ /**
+ * Check if a peer's cache entry has a vaild MitM key.
+ *
+ * If true then the other peer ha a valid MtiM key, i.e. the peer has performed
+ * the enrollment procedure. A PBX ZRTP Back-2-Back application can use this function
+ * to check which of the peers is enrolled.
+ *
+ * @return True if the other peer has a valid Mitm key (is enrolled).
+ */
+ bool isPeerEnrolled();
+
+ /**
+ * Set the state of the SAS signature mode flag.
+ *
+ * If SAS signature mode is set to true this ZRTP session support SAS signature
+ * callbacks and signature transfer between clients.
+ *
+ * @param sasSignMode defines the new state of the sasSignMode flag
+ */
+ void setSignSas(bool sasSignMode);
+
+ /**
+ * Set signature data
+ *
+ * This functions stores signature data and transmitts it during ZRTP
+ * processing to the other party as part of the Confirm packets. Refer to
+ * chapters 6.7 and 8.2 in the ZRTP specification.
+ *
+ * @param data
+ * The signature data including the signature type block. The method
+ * copies this data into the Confirm packet at signature type block.
+ * @param length
+ * The length of the signature data in bytes. This length must be
+ * multiple of 4.
+ * @return
+ * True if the method stored the data, false otherwise.
+ */
+ bool setSignatureData(uint8* data, int32 length);
+
+ /**
+ * Get signature data
+ *
+ * This functions returns signature data that was receivied during ZRTP
+ * processing. Refer to chapters 6.7 and 8.2.
+ *
+ * @return
+ * Pointer to signature data. This is a pointer to volatile data that is
+ * only valid during the checkSASSignature() callback. The application
+ * shall copy the data if necessary.
+ */
+ const uint8* getSignatureData();
+
+ /**
+ * Get length of signature data
+ *
+ * This functions returns the length of signature data that was receivied
+ * during ZRTP processing. Refer to chapters 6.7 and 8.2.
+ *
+ * @return
+ * Length in bytes of the received signature data. The method returns
+ * zero if no signature data avilable.
+ */
+ int32 getSignatureLength();
+
+ /**
+ * Put data into the RTP output queue.
+ *
+ * This is used to create a data packet in the send queue.
+ * Sometimes a "NULL" or empty packet will be used instead, and
+ * these are known as "silent" packets. "Silent" packets are
+ * used simply to "push" the scheduler along more accurately
+ * by giving the appearence that a next packet is waiting to
+ * be sent and to provide a valid timestamp for that packet.
+ *
+ * This method overrides the same method in OutgoingDataQueue class.
+ * During ZRTP processing it may be necessary to control the
+ * flow of outgoing RTP payload packets (GoClear processing).
+ *
+ * @param stamp Timestamp for expected send time of packet.
+ * @param data Value or NULL if special "silent" packet.
+ * @param len May be 0 to indicate a default by payload type.
+ **/
+ void
+ putData(uint32 stamp, const unsigned char* data = NULL, size_t len = 0);
+
+ /**
+ * Immediatly send a data packet.
+ *
+ * This is used to create a data packet and send it immediately.
+ * Sometimes a "NULL" or empty packet will be used instead, and
+ * these are known as "silent" packets. "Silent" packets are
+ * used simply to "push" the scheduler along more accurately
+ * by giving the appearence that a next packet is waiting to
+ * be sent and to provide a valid timestamp for that packet.
+ *
+ * This method overrides the same method in OutgoingDataQueue
+ * class. During ZRTP processing it may be necessary to
+ * control the flow of outgoing RTP payload packets (GoClear
+ * processing).
+ *
+ * @param stamp Timestamp immediate send time of packet.
+ * @param data Value or NULL if special "silent" packet.
+ * @param len May be 0 to indicate a default by payload type.
+ **/
+ void
+ sendImmediate(uint32 stamp, const unsigned char* data = NULL, size_t len = 0);
+
+ /**
+ * Starts the ZRTP protocol engine.
+ *
+ * Applications may call this method to immediatly start the ZRTP protocol
+ * engine any time after initializing ZRTP and setting optinal parameters,
+ * for example client id or multi-stream parameters.
+ *
+ * If the application does not call this method but sucessfully initialized
+ * the ZRTP engine using <code>initialize()</code> then ZRTP also starts
+ * after the application sent and received RTP packets. An application can
+ * disable this automatic, delayed start of the ZRTP engine using
+ * <code>setEnableZrtp(false)</code> before sending or receiving RTP
+ * packets.
+ *
+ */
+ void startZrtp();
+
+ /**
+ * Stops the ZRTP protocol engine.
+ *
+ * Applications call this method to stop the ZRTP protocol
+ * engine.
+ *
+ */
+ void stopZrtp();
+
+ /**
+ * Get other party's ZID (ZRTP Identifier) data
+ *
+ * This functions returns the other party's ZID that was receivied
+ * during ZRTP processing.
+ *
+ * The ZID data can be retrieved after ZRTP receive the first Hello
+ * packet from the other party. The application may call this method
+ * for example during SAS processing in showSAS(...) user callback
+ * method.
+ *
+ * @param data
+ * Pointer to a data buffer. This buffer must have a size of
+ * at least 12 bytes (96 bit) (ZRTP Identifier, see chap. 4.9)
+ * @return
+ * Number of bytes copied into the data buffer - must be equivalent
+ * to 96 bit, usually 12 bytes.
+ */
+ int32 getPeerZid(uint8* data);
+
+protected:
+ friend class TimeoutProvider<std::string, ost::ZrtpQueue*>;
+
+ /**
+ * A hook that gets called if the decoding of an incoming SRTP
+ * was erroneous
+ *
+ * @param pkt
+ * The SRTP packet with error.
+ * @param errorCode
+ * The error code: -1 - SRTP authentication failure, -2 - replay
+ * check failed
+ * @return
+ * True: put the packet in incoming queue for further processing
+ * by the applications; false: dismiss packet. The default
+ * implementation returns false.
+ */
+ virtual bool
+ onSRTPPacketError(IncomingRTPPkt& pkt, int32 errorCode);
+
+ /**
+ * Handle timeout event forwarded by the TimeoutProvider.
+ *
+ * Just call the ZRTP engine for further processing.
+ */
+ void handleTimeout(const std::string &c);
+
+ /**
+ * This function is used by the service thread to process
+ * the next incoming packet and place it in the receive list.
+ *
+ * This class overloads the function of IncomingDataQueue
+ * implementation.
+ *
+ * @return number of payload bytes received, <0 if error.
+ */
+ virtual size_t takeInDataPacket();
+
+ /*
+ * The following methods implement the GNU ZRTP callback interface.
+ * For detailed documentation refer to file ZrtpCallback.h
+ */
+ int32_t sendDataZRTP(const unsigned char* data, int32_t length);
+
+ int32_t activateTimer(int32_t time);
+
+ int32_t cancelTimer();
+
+ void sendInfo(GnuZrtpCodes::MessageSeverity severity, int32_t subCode);
+
+ bool srtpSecretsReady(SrtpSecret_t* secrets, EnableSecurity part);
+
+ void srtpSecretsOff(EnableSecurity part);
+
+ void srtpSecretsOn(std::string c, std::string s, bool verified);
+
+ void handleGoClear();
+
+ void zrtpNegotiationFailed(GnuZrtpCodes::MessageSeverity severity, int32_t subCode);
+
+ void zrtpNotSuppOther();
+
+ void synchEnter();
+
+ void synchLeave();
+
+ void zrtpAskEnrollment(GnuZrtpCodes::InfoEnrollment info);
+
+ void zrtpInformEnrollment(GnuZrtpCodes::InfoEnrollment info);
+
+ void signSAS(uint8_t* sasHash);
+
+ bool checkSASSignature(uint8_t* sasHash);
+
+ /*
+ * End of ZrtpCallback functions.
+ */
+
+ ZrtpQueue(uint32 size = RTPDataQueue::defaultMembersHashSize,
+ RTPApplication& app = defaultApplication());
+
+ /**
+ * Local SSRC is given instead of computed by the queue.
+ */
+ ZrtpQueue(uint32 ssrc, uint32 size =
+ RTPDataQueue::defaultMembersHashSize,
+ RTPApplication& app = defaultApplication());
+
+ virtual ~ZrtpQueue();
+
+private:
+ void init();
+ size_t rtpDataPacket(unsigned char* packet, int32 rtn,
+ InetHostAddress network_address,
+ tpport_t transport_port);
+
+ ZRtp *zrtpEngine;
+ ZrtpUserCallback* zrtpUserCallback;
+
+ std::string clientIdString;
+
+ bool enableZrtp;
+
+ int32 secureParts;
+
+ int16 senderZrtpSeqNo;
+ ost::Mutex synchLock; // Mutex for ZRTP (used by ZrtpStateClass)
+ uint32 peerSSRC;
+ bool started;
+ bool mitmMode;
+ bool signSas;
+ bool enableParanoidMode;
+};
+
+class IncomingZRTPPkt : public IncomingRTPPkt {
+
+public:
+ /**
+ * Build a ZRTP packet object from a data buffer.
+ *
+ * @param block pointer to the buffer the whole packet is stored in.
+ * @param len length of the whole packet, expressed in octets.
+ *
+ **/
+
+ IncomingZRTPPkt(const unsigned char* block, size_t len);
+
+ ~IncomingZRTPPkt()
+ { }
+
+ uint32
+ getZrtpMagic() const;
+
+ uint32
+ getSSRC() const;
+};
+
+class OutgoingZRTPPkt : public OutgoingRTPPkt {
+
+public:
+ /**
+ * Construct a new ZRTP packet to be sent.
+ *
+ * A new copy in memory (holding all this components
+ * along with the fixed header) is created.
+ *
+ * @param hdrext whole header extension.
+ * @param hdrextlen size of whole header extension, in octets.
+ **/
+ OutgoingZRTPPkt(const unsigned char* const hdrext, uint32 hdrextlen);
+ ~OutgoingZRTPPkt()
+ { }
+};
+
+END_NAMESPACE
+
+#endif
+
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-default-style: ellemtel
+ * c-basic-offset: 4
+ * End:
+ */
+
diff --git a/src/libzrtpcpp/ZrtpStateClass.h b/src/libzrtpcpp/ZrtpStateClass.h
new file mode 100644
index 0000000..fba061d
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpStateClass.h
@@ -0,0 +1,324 @@
+/*
+ Copyright (C) 2006-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 _ZRTPSTATECLASS_H_
+#define _ZRTPSTATECLASS_H_
+
+/**
+ * @file ZrtpStateClass.h
+ * @brief The ZRTP state handling class
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <libzrtpcpp/ZrtpStates.h>
+#include <libzrtpcpp/ZrtpPacketBase.h>
+
+/**
+ * The ZRTP states
+ *
+ * Depending on the role of this state engine and the actual protocl flow
+ * not all states are processed during a ZRTP handshake.
+ */
+enum zrtpStates {
+ Initial, ///< Initial state after starting the state engine
+ Detect, ///< State sending Hello, try to detect answer message
+ AckDetected, ///< HelloAck received
+ AckSent, ///< HelloAck sent after Hello received
+ WaitCommit, ///< Wait for a Commit message
+ CommitSent, ///< Commit message sent
+ WaitDHPart2, ///< Wait for a DHPart2 message
+ WaitConfirm1, ///< Wait for a Confirm1 message
+ WaitConfirm2, ///< Wait for a confirm2 message
+ WaitConfAck, ///< Wait for Conf2Ack
+ WaitClearAck, ///< Wait for clearAck - not used
+ SecureState, ///< This is the secure state - SRTP active
+ WaitErrorAck, ///< Wait for ErrorAck message
+ numberOfStates ///< Gives total number of protocol states
+};
+
+enum EventReturnCodes {
+ Fail = 0, ///< ZRTP event processing failed.
+ Done = 1 ///< Event processing ok.
+};
+
+enum EventDataType {
+ ZrtpInitial = 1, ///< Initial event, enter Initial state
+ ZrtpClose, ///< Close event, shut down state engine
+ ZrtpPacket, ///< Normal ZRTP message event, process according to state
+ Timer, ///< Timer event
+ ErrorPkt ///< Error packet event
+};
+
+enum SecureSubStates {
+ Normal,
+ WaitSasRelayAck,
+ numberofSecureSubStates
+};
+
+/// A ZRTP state event
+typedef struct Event {
+ EventDataType type; ///< Type of event
+ uint8_t* packet; ///< Event data if availabe, usually a ZRTP message
+} Event_t;
+
+
+/**
+ * The ZRTP timer structure.
+ *
+ * This structure holds all necessary data to compute the timer for
+ * the protocol timers. The state engine allocate one structure for
+ * each timer. ZRTP uses two timers, T1 and T2, to monitor protocol
+ * timeouts. As a slight misuse but to make overall handling a bit
+ * simpler this structure also contains the resend counter. This is
+ * possible in ZRTP because it uses a simple timeout strategy.
+ */
+typedef struct zrtpTimer {
+ int32_t time, ///< Current timeout value
+ start, ///< Start value for timeout
+ increment, ///< increment timeout after each timeout event (not used anymore)
+ capping, ///< Maximum timeout value
+ counter, ///< Current number of timeouts
+ maxResend; ///< Maximum number of timeout resends
+} zrtpTimer_t;
+
+
+class ZRtp;
+
+/**
+ * This class is the ZRTP protocol state engine.
+ *
+ * This class is responsible to handle the ZRTP protocol. It does not
+ * handle the ZRTP HMAC, DH, and other data management. This is done in
+ * class ZRtp, which is the parent of this class.
+ *
+ * The methods of this class implement the ZRTP state actions.
+ *
+ */
+
+
+class __EXPORT ZrtpStateClass {
+
+private:
+ ZRtp* parent; ///< The ZRTP implmentation
+ ZrtpStates* engine; ///< The state switching engine
+ Event_t* event; ///< Current event to process
+
+ /**
+ * The last packet that was sent.
+ *
+ * If we are <code>Initiator</code> then resend this packet in case of
+ * timeout.
+ */
+ ZrtpPacketBase* sentPacket;
+
+ /**
+ * Points to prepared Commit packet after receiving a Hello packet
+ */
+ ZrtpPacketCommit* commitPkt;
+
+ zrtpTimer_t T1; ///< The Hello message timeout timer
+ zrtpTimer_t T2; ///< Timeout timer for other messages
+
+ /*
+ * If this is set to true the protocol engine handle the multi-stream
+ * variant of ZRTP. Refer to chapter 5.4.2 in the ZRTP specification.
+ */
+ bool multiStream;
+
+ // Secure substate to handle SAS relay packets
+ SecureSubStates secSubstate;
+
+ /**
+ * Secure Sub state WaitSasRelayAck.
+ *
+ * This state belongs to the secure substates and handles
+ * SAS Relay Ack.
+ *
+ * When entering this transition function
+ * - sentPacket contains Error packet, Error timer active
+ *
+ * Possible events in this state are:
+ * - timeout for sent SAS Relay packet: causes a resend check and repeat sending
+ * of packet
+ * - SASRelayAck: Stop timer and switch to secure substate Normal.
+ */
+ bool subEvWaitRelayAck();
+
+public:
+ /// Create a ZrtpStateClass
+ ZrtpStateClass(ZRtp *p);
+ ~ZrtpStateClass();
+
+ /// Check if in a specified state
+ bool inState(const int32_t state) { return engine->inState(state); };
+
+ /// Switch to the specified state
+ void nextState(int32_t state) { engine->nextState(state); };
+
+ /// Process an event, the main entry point into the state engine
+ void processEvent(Event_t *ev);
+
+ /**
+ * The state event handling methods.
+ *
+ * Refer to the protocol state diagram for further documentation.
+ */
+ /// Initial event state
+ void evInitial();
+
+ /// Detect state
+ void evDetect();
+
+ /// HelloAck detected state
+ void evAckDetected();
+
+ /// HelloAck sent state
+ void evAckSent();
+
+ /// Wait for Commit message
+ void evWaitCommit();
+
+ /// Commit sent state
+ void evCommitSent();
+
+ /// Wait for DHPart2 message
+ void evWaitDHPart2();
+
+ /// Wait for Confirm2 message
+ void evWaitConfirm1();
+
+ /// Wait for Confirm2 message
+ void evWaitConfirm2();
+
+ /// Wait for ConfAck message
+ void evWaitConfAck();
+
+ /// Wait for ClearAck message (not used)
+ void evWaitClearAck();
+
+ /// Secure reached state
+ void evSecureState();
+
+ /// Wait for ErrorAck message
+ void evWaitErrorAck();
+
+ /**
+ * Initialize and activate a timer.
+ *
+ * @param t
+ * The ZRTP timer structure to use for the timer.
+ * @return
+ * 1 timer was activated
+ * 0 activation failed
+ */
+ int32_t startTimer(zrtpTimer_t *t);
+
+ /**
+ * Compute and set the next timeout value.
+ *
+ * @param t
+ * The ZRTP timer structure to use for the timer.
+ * @return
+ * 1 timer was activated
+ * 0 activation failed
+ * -1 resend counter exceeded
+ */
+ int32_t nextTimer(zrtpTimer_t *t);
+
+ /**
+ * Cancel the active timer.
+ *
+ * @return
+ * 1 timer was canceled
+ * 0 cancelation failed
+ */
+ int32_t cancelTimer() {return parent->cancelTimer(); };
+
+ /**
+ * Prepare and send an Error packet.
+ *
+ * Preparse an Error packet and sends it. It stores the Error
+ * packet in the sentPacket variable to enable resending. The
+ * method switches to protocol state Initial.
+ */
+ void sendErrorPacket(uint32_t errorCode);
+
+ /**
+ * Set status if an error occured while sending a ZRTP packet.
+ *
+ * This functions clears data and set the state to Initial after the engine
+ * detected a problem while sending a ZRTP packet.
+ *
+ * @return
+ * Fail code
+ */
+ void sendFailed();
+
+ /**
+ * Set status if a timer problems occure.
+ *
+ * This functions clears data and set state to Initial after a timer
+ * error occured. Either no timer available or resend counter exceedeed.
+ *
+ * @return
+ * Fail code
+ */
+ void timerFailed(int32_t subCode);
+
+ /**
+ * Set multi-stream mode flag.
+ *
+ * This functions set the multi-stream mode. The protocol
+ * engine will run the multi-stream mode variant of the ZRTP
+ * protocol if this flag is set to true.
+ *
+ * @param multi
+ * Set the multi-stream mode flag to true or false.
+ */
+ void setMultiStream(bool multi);
+
+ /**
+ * Status of multi-stream mode flag.
+ *
+ * This functions returns the value of the multi-stream mode flag.
+ *
+ * @return
+ * Value of the multi-stream mode flag.
+ */
+ bool isMultiStream();
+
+ /**
+ * Send a SAS relay packet.
+ *
+ * the functions stores sends the SAS relay packet and stores the pointer in
+ * the sentPacket variable to enable resending.
+ *
+ * The method switches to secure substate WaitSasRelayAck.
+ *
+ * @param relay
+ * Pointer to the SAS relay packet.
+ */
+ void sendSASRelay(ZrtpPacketSASrelay* relay);
+};
+
+/**
+ * @}
+ */
+#endif // _ZRTPSTATECLASS_H_
+
diff --git a/src/libzrtpcpp/ZrtpStates.h b/src/libzrtpcpp/ZrtpStates.h
new file mode 100644
index 0000000..44662a0
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpStates.h
@@ -0,0 +1,90 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#ifndef _ZRTPSTATES_H_
+#define _ZRTPSTATES_H_
+
+/**
+ * @file ZrtpStates.h
+ * @brief The ZRTP state switching class
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stdint.h>
+
+class __EXPORT ZrtpStateClass;
+/**
+ * This structure hold the state name as enum (int) number and the pointer to
+ * the functions that handles the various triggers that can occur in a state.
+ */
+typedef struct {
+ int32_t stateName; ///< The state number
+ void (ZrtpStateClass::* handler)(void); ///< The state handler
+} state_t;
+
+/**
+ * Implement a simple state switching.
+ *
+ * This class provides functions that manage the states and the event handler
+ * functions. Its a very simple implementation.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+class __EXPORT ZrtpStates {
+ public:
+
+ /// Create an initialize state switching
+ ZrtpStates(state_t* const zstates,
+ const int32_t numStates,
+ const int32_t initialState):
+ numStates(numStates), states(zstates), state(initialState) {}
+
+ /// Call a state handler
+ int32_t processEvent(ZrtpStateClass& zsc) {
+ (zsc.*states[state].handler)();
+ return 0;
+ }
+
+ /// Check if in specified state
+ bool inState(const int32_t s) { return ((s == state)); }
+
+ /// Set the next state
+ void nextState(int32_t s) { state = s; }
+
+ private:
+ const int32_t numStates;
+ const state_t* states;
+ int32_t state;
+
+ ZrtpStates();
+};
+
+/**
+ * @}
+ */
+#endif //ZRTPSTATES
+
diff --git a/src/libzrtpcpp/ZrtpTextData.h b/src/libzrtpcpp/ZrtpTextData.h
new file mode 100644
index 0000000..e79cb98
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpTextData.h
@@ -0,0 +1,124 @@
+/*
+ Copyright (C) 2006-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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#ifndef _ZRTPTEXTDATA_H_
+#define _ZRTPTEXTDATA_H_
+
+/**
+ * @file ZrtpTextData.h
+ * @brief The ZRTP ASCII texts - extern references
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <libzrtpcpp/ZrtpConfigure.h>
+
+/**
+ * The extern references to the global data.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+extern char clientId[];
+extern char zrtpVersion[];
+
+/**
+ *
+ */
+extern char HelloMsg[];
+extern char HelloAckMsg[];
+extern char CommitMsg[];
+extern char DHPart1Msg[];
+extern char DHPart2Msg[];
+extern char Confirm1Msg[];
+extern char Confirm2Msg[];
+extern char Conf2AckMsg[];
+extern char ErrorMsg[];
+extern char ErrorAckMsg[];
+extern char GoClearMsg[];
+extern char ClearAckMsg[];
+extern char PingMsg[];
+extern char PingAckMsg[];
+extern char SasRelayMsg[];
+extern char RelayAckMsg[];
+
+/**
+ *
+ */
+extern char responder[];
+extern char initiator[];
+extern char iniMasterKey[];
+extern char iniMasterSalt[];
+extern char respMasterKey[];
+extern char respMasterSalt[];
+
+extern char iniHmacKey[];
+extern char respHmacKey[];
+extern char retainedSec[];
+
+extern char iniZrtpKey[];
+extern char respZrtpKey[];
+
+extern char sasString[];
+
+extern char KDFString[];
+extern char zrtpSessionKey[];
+extern char zrtpMsk[];
+extern char zrtpTrustedMitm[];
+
+
+extern char s256[];
+extern char s384[];
+extern const char* mandatoryHash;
+
+extern char aes3[];
+extern char aes2[];
+extern char aes1[];
+extern char two3[];
+extern char two2[];
+extern char two1[];
+
+extern const char* mandatoryCipher;
+
+extern char dh2k[];
+extern char dh3k[];
+extern char ec25[];
+extern char ec38[];
+
+extern char mult[];
+
+extern const char* mandatoryPubKey;
+
+extern char b32[];
+extern const char* mandatorySasType;
+
+extern char hs32[];
+extern char hs80[];
+extern char sk32[];
+extern char sk64[];
+extern const char* mandatoryAuthLen_1;
+extern const char* mandatoryAuthLen_2;
+
+/**
+ * @}
+ */
+#endif // _ZRTPTEXTDATA_H_
+
diff --git a/src/libzrtpcpp/ZrtpUserCallback.h b/src/libzrtpcpp/ZrtpUserCallback.h
new file mode 100644
index 0000000..3e4871c
--- /dev/null
+++ b/src/libzrtpcpp/ZrtpUserCallback.h
@@ -0,0 +1,234 @@
+/*
+ Copyright (C) 2006-2008 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 _ZRTPUSERCALLBACK_H_
+#define _ZRTPUSERCALLBACK_H_
+
+/**
+ * @file ZrtpUserCallback.h
+ * @brief The ZRTP UserCallback class
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <stdint.h>
+#include <string>
+
+#include <libzrtpcpp/ZrtpCodes.h>
+
+/**
+ * Application callback methods.
+ *
+ * The ccRTP specific part of GNU ZRTP uses these callback methods
+ * to report ZRTP events to the application. This class implements a
+ * default behaviour for each callback method, usually just a return.
+ *
+ * An application may extend this class and overload methods
+ * to implement its own behaviour. The application must register its
+ * callback class using ZrtpQueue#setUserCallback().
+ *
+ * <b>CAVEAT</b><br/>
+ * All methods of the user callback class and classes that
+ * extend this class run in the context of the RTP thread. Thus it is
+ * of paramount importance to keep the execution time of the methods
+ * as short as possible.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+class __EXPORT ZrtpUserCallback {
+
+ public:
+
+ /// Create the stadard user callback class.
+ ZrtpUserCallback() {}
+
+ virtual ~ZrtpUserCallback() {};
+
+ /**
+ * Inform user interface that security is active now.
+ *
+ * ZRTP calls this method if the sender and the receiver are
+ * in secure mode now.
+ *
+ * @param cipher
+ * Name and mode of cipher used to encrypt the SRTP stream
+ */
+ virtual void secureOn(std::string cipher) {
+ return;
+ }
+ /**
+ * Inform user interface that security is not active any more.
+ *
+ * ZRTP calls this method if either the sender or the receiver
+ * left secure mode.
+ *
+ */
+ virtual void secureOff() {
+ return;
+ }
+
+ /**
+ * Show the Short Authentication String (SAS) on user interface.
+ *
+ * ZRTP calls this method to display the SAS and inform about the SAS
+ * verification status. The user interface shall enable a SAS verfication
+ * button (or similar UI element). The user shall click on this UI
+ * element after he/she confirmed the SAS code with the partner.
+ *
+ * @param sas
+ * The string containing the SAS.
+ * @param verified
+ * If <code>verified</code> is true then SAS was verified by both
+ * parties during a previous call, otherwise it is set to false.
+ */
+ virtual void showSAS(std::string sas, bool verified) {
+ return;
+ }
+
+ /**
+ * Inform the user that ZRTP received "go clear" message from its peer.
+ *
+ * On receipt of a go clear message the user is requested to confirm
+ * a switch to unsecure (clear) modus. Until the user confirms ZRTP
+ * (and the underlying RTP) does not send any data.
+ */
+ virtual void confirmGoClear() {
+ return;
+ }
+
+ /**
+ * Show some information to user.
+ *
+ * ZRTP calls this method to display some information to the user.
+ * Along with the message ZRTP provides a severity indicator that
+ * defines: Info, Warning, Error, and Alert. Refer to the <code>
+ * MessageSeverity</code> enum in <code>ZrtpCodes.h</code>. The
+ * UI may use this indicator to highlight messages or alike.
+ *
+ * @param sev
+ * Severity of the message.
+ * @param subCode
+ * The subcode identifying the reason.
+ */
+ virtual void showMessage(GnuZrtpCodes::MessageSeverity sev, int32_t subCode) {
+ return;
+ }
+
+ /**
+ * ZRTPQueue calls this if the negotiation failed.
+ *
+ * ZRTPQueue calls this method in case ZRTP negotiation failed. The
+ * parameters show the severity as well as some explanatory text.
+ * Refer to the <code>MessageSeverity</code> enum above.
+ *
+ * @param severity
+ * This defines the message's severity
+ * @param subCode
+ * The subcode identifying the reason.
+ */
+ virtual void zrtpNegotiationFailed(GnuZrtpCodes::MessageSeverity severity,
+ int32_t subCode) {
+ return;
+ }
+
+ /**
+ * ZRTPQueue calls this method if the other side does not support ZRTP.
+ *
+ * If the other side does not answer the ZRTP <em>Hello</em> packets then
+ * ZRTP calls this method.
+ *
+ */
+ virtual void zrtpNotSuppOther() {
+ return;
+ }
+
+ /**
+ * ZRTPQueue calls this method to inform about a PBX enrollment request.
+ *
+ * Please refer to chapter 8.3 ff to get more details about PBX enrollment
+ * and SAS relay.
+ *
+ * @param info
+ * Give some information to the user about the PBX requesting an
+ * enrollment.
+ *
+ */
+ virtual void zrtpAskEnrollment(GnuZrtpCodes::InfoEnrollment info) {
+ return;
+ }
+
+ /**
+ * ZRTPQueue calls this method to inform about PBX enrollment result.
+ *
+ * Informs the use about the acceptance or denial of an PBX enrollment
+ * request
+ *
+ * @param info
+ * Give some information to the user about the result of an
+ * enrollment.
+ *
+ */
+ virtual void zrtpInformEnrollment(GnuZrtpCodes::InfoEnrollment info) {
+ return;
+ }
+
+ /**
+ * ZRTPQueue calls this method to request a SAS signature.
+ *
+ * After ZRTP core was able to compute the Short Authentication String
+ * (SAS) it calls this method. The client may now use an approriate
+ * method to sign the SAS. The client may use
+ * setSignatureData() of ZrtpQueue to store the signature
+ * data an enable signature transmission to the other peer. Refer
+ * to chapter 8.2 of ZRTP specification.
+ *
+ * @param sasHash
+ * Pointer to the 32 byte SAS hash to be signed.
+ * @see ZrtpQueue#setSignatureData
+ *
+ */
+ virtual void signSAS(uint8_t* sasHash) {
+ return;
+ }
+
+ /**
+ * ZRTPQueue calls this method to request a SAS signature check.
+ *
+ * After ZRTP received a SAS signature in one of the Confirm packets it
+ * call this method. The client may use <code>getSignatureLength()</code>
+ * and <code>getSignatureData()</code>of ZrtpQueue to get the signature
+ * data and perform the signature check. Refer to chapter 8.2 of ZRTP
+ * specification.
+ *
+ * If the signature check fails the client may return false to ZRTP. In
+ * this case ZRTP signals an error to the other peer and terminates
+ * the ZRTP handshake.
+ *
+ * @param sasHash
+ * Pointer to the 32 byte SAS hash that was signed by the other peer.
+ * @return
+ * true if the signature was ok, false otherwise.
+ *
+ */
+ virtual bool checkSASSignature(uint8_t* sasHash) {
+ return true;
+ }
+};
+
+#endif
diff --git a/src/libzrtpcpp/crypto/TwoCFB.cpp b/src/libzrtpcpp/crypto/TwoCFB.cpp
new file mode 100755
index 0000000..be3dda4
--- /dev/null
+++ b/src/libzrtpcpp/crypto/TwoCFB.cpp
@@ -0,0 +1,79 @@
+/*
+ Copyright (C) 2011 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) 2011
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <string.h>
+
+#include <libzrtpcpp/crypto/twoCFB.h>
+#include <libzrtpcpp/crypto/twofish.h>
+
+static int initialized = 0;
+
+void twoCfbEncrypt(uint8_t* key, int32_t keyLength, uint8_t* IV, uint8_t *data,
+ int32_t dataLength)
+{
+ Twofish_key keyCtx;
+ int usedBytes = 0;
+
+ if (!initialized) {
+ Twofish_initialise();
+ initialized = 1;
+ }
+
+ memset(&keyCtx, 0, sizeof(Twofish_key));
+ Twofish_prepare_key(key, keyLength, &keyCtx);
+
+ Twofish_cfb128_encrypt(&keyCtx, (Twofish_Byte*)data, (Twofish_Byte*)data,
+ (size_t)dataLength, (Twofish_Byte*)IV, &usedBytes);
+}
+
+
+void twoCfbDecrypt(uint8_t* key, int32_t keyLength, const uint8_t* IV, uint8_t *data,
+ int32_t dataLength)
+{
+ Twofish_key keyCtx;
+ int usedBytes = 0;
+
+ if (!initialized) {
+ Twofish_initialise();
+ initialized = 1;
+ }
+
+ memset(&keyCtx, 0, sizeof(Twofish_key));
+ Twofish_prepare_key(key, keyLength, &keyCtx);
+
+ Twofish_cfb128_decrypt(&keyCtx, (Twofish_Byte*)data, (Twofish_Byte*)data,
+ (size_t)dataLength, (Twofish_Byte*)IV, &usedBytes);
+}
diff --git a/src/libzrtpcpp/crypto/ZrtpDH.h b/src/libzrtpcpp/crypto/ZrtpDH.h
new file mode 100644
index 0000000..bd32f7f
--- /dev/null
+++ b/src/libzrtpcpp/crypto/ZrtpDH.h
@@ -0,0 +1,168 @@
+/*
+ Copyright (C) 2006-2009 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#ifndef _ZRTPDH_H__
+#define _ZRTPDH_H__
+
+#include <stdint.h>
+#include <libzrtpcpp/ZrtpConfigure.h>
+
+/**
+ * @file ZrtpDH.h
+ * @brief Class that implemets Diffie-Helman key agreement for ZRTP
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+/**
+ * Generates a number of random bytes.
+ *
+ * @param buf
+ * Pointer to a buffer that receives the random data. Must have a size
+ * of at least <code>length</code> bytes.
+ *
+ * @param length
+ * Number of random bytes to produce.
+ */
+void randomZRTP(uint8_t *buf, int32_t length);
+
+const int32_t DH2K = 0;
+const int32_t DH3K = 1;
+const int32_t EC25 = 2;
+const int32_t EC38 = 3;
+
+
+/**
+ * Implementation of Diffie-Helman for ZRTP
+ *
+ * This class defines functions to generate and compute the
+ * Diffie-Helman public and secret data and the shared secret. According to
+ * the ZRTP specification we use the MODP groups as defined by RFC 3526 for
+ * length 3072 and 4096.
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+class ZrtpDH {
+
+private:
+ void* ctx; ///< Context the DH
+ int pkType; ///< Which type of DH to use
+
+public:
+ /**
+ * Create a Diffie-Helman key agreement algorithm
+ *
+ * @param type
+ * Name of the DH algorithm to use
+ */
+ ZrtpDH(const char* type);
+
+ ~ZrtpDH();
+
+ /**
+ * Generates a public key based on the DH parameters and a random
+ * private key.
+ *
+ * @return 1 on success, 0 on failure
+ */
+ int32_t generatePublicKey();
+
+ /**
+ * Returns the size in bytes of the DH parameter p.
+ *
+ * @return Size in bytes.
+ */
+ int32_t getDhSize() const;
+
+ /**
+ * Returns the size in bytes of computed public key.
+ *
+ * @return Size in bytes.
+ */
+ int32_t getPubKeySize() const;
+
+ /**
+ * Returns the bytes of computed secret key.
+ *
+ * Returns the bytes of the public key in network (big endian) order.#
+ *
+ * @param buf
+ * Pointer to a buffer of at least <code>getPubKeySize()</code> bytes.
+ *
+ * @return Size in bytes.
+ */
+ int32_t getPubKeyBytes(uint8_t *buf) const;
+
+ /**
+ * Compute the secret key and returns it to caller.
+ *
+ * This method computes the secret key based on the DH parameters, the
+ * private key and the peer's public key.
+ *
+ * @param pubKeyBytes
+ * Pointer to the peer's public key bytes. Must be in big endian order.
+ *
+ * @param secret
+ * Pointer to a buffer that receives the secret key. This buffer must
+ * have a length of at least <code>getSecretSize()</code> bytes.
+ *
+ * @return the size of the shared secret on success, -1 on error.
+ */
+ int32_t computeSecretKey(uint8_t *pubKeyBytes, uint8_t *secret);
+
+ /**
+ * Check and validate the public key received from peer.
+ *
+ * Check if this is a correct Diffie-Helman public key. If the public
+ * key value is either one or (P-1) then this is a wrong public key
+ * value.
+ *
+ * @param pubKeyBytes
+ * Pointer to the peer's public key bytes. Must be in big endian order.
+ *
+ * @return 0 if check faild, 1 if public key value is ok.
+ */
+ int32_t checkPubKey(uint8_t* pubKeyBytes) const;
+
+ /**
+ * Get type of DH algorithm.
+ *
+ * @return
+ * Pointer to DH algorithm name
+ */
+ const char* getDHtype();
+};
+
+#endif // ZRTPDH_H
+
+/**
+ * @}
+ */
+
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-default-style: ellemtel
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/src/libzrtpcpp/crypto/aesCFB.h b/src/libzrtpcpp/crypto/aesCFB.h
new file mode 100644
index 0000000..6b4ab6e
--- /dev/null
+++ b/src/libzrtpcpp/crypto/aesCFB.h
@@ -0,0 +1,87 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#ifndef _AESCFB_H__
+#define _AESCFB_H__
+
+#include <stdint.h>
+
+/**
+ * @file aesCFB.h
+ * @brief Function that provide AES CFB mode support
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#ifndef AES_BLOCK_SIZE
+#define AES_BLOCK_SIZE 16
+#endif
+
+/**
+ * Encrypt data with AES CFB mode, full block feedback size.
+ *
+ * This functions takes one data chunk and encrypts it with
+ * AES CFB mode. The lenght of the data may be arbitrary and
+ * it is not needed to be a multiple of AES blocksize.
+ *
+ * @param key
+ * Points to the key bytes.
+ * @param keyLength
+ * Length of the key in bytes
+ * @param IV
+ * The initialization vector which must be AES_BLOCKSIZE (16) bytes.
+ * @param data
+ * Points to a buffer that contains and receives the computed
+ * the data (in-place encryption).
+ * @param dataLength
+ * Length of the data in bytes
+ */
+
+void aesCfbEncrypt(uint8_t* key, int32_t keyLength, uint8_t* IV, uint8_t *data,
+ int32_t dataLength);
+
+/**
+ * Decrypt data with AES CFB mode, full block feedback size.
+ *
+ * This functions takes one data chunk and decrypts it with
+ * AES CFB mode. The lenght of the data may be arbitrary and
+ * it is not needed to be a multiple of AES blocksize.
+ *
+ * @param key
+ * Points to the key bytes.
+ * @param keyLength
+ * Length of the key in bytes
+ * @param IV
+ * The initialization vector which must be AES_BLOCKSIZE (16) bytes.
+ * @param data
+ * Points to a buffer that contains and receives the computed
+ * the data (in-place decryption).
+ * @param dataLength
+ * Length of the data in bytes
+ */
+
+void aesCfbDecrypt(uint8_t* key, int32_t keyLength, const uint8_t* IV, uint8_t *data,
+ int32_t dataLength);
+/**
+ * @}
+ */
+#endif
diff --git a/src/libzrtpcpp/crypto/gcrypt/InitializeGcrypt.cpp b/src/libzrtpcpp/crypto/gcrypt/InitializeGcrypt.cpp
new file mode 100644
index 0000000..1372578
--- /dev/null
+++ b/src/libzrtpcpp/crypto/gcrypt/InitializeGcrypt.cpp
@@ -0,0 +1,130 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+#include <stdio.h>
+
+#include <malloc.h>
+#include <errno.h>
+#include <gcrypt.h>
+
+#include <libzrtpcpp-config.h>
+#ifdef HAVE_PTHREAD_H
+#include <pthread.h>
+#else
+#include <winbase.h>
+#endif
+
+static int initialized = 0;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef HAVE_PTHREAD_H
+static int gcry_thread_mutex_init (void **priv)
+{
+ int err = 0;
+ pthread_mutex_t *lock = (pthread_mutex_t *)malloc (sizeof (pthread_mutex_t));
+ if (!lock)
+ err = ENOMEM;
+ if (!err) {
+ err = pthread_mutex_init (lock, NULL);
+ if (err)
+ free (lock);
+ else
+ *priv = lock;
+ }
+ return err;
+}
+
+static int gcry_thread_mutex_destroy (void **lock)
+{
+ int err = pthread_mutex_destroy ((pthread_mutex_t *)*lock);
+ free (*lock); return err;
+}
+
+static int gcry_thread_mutex_lock (void **lock)
+{
+ return pthread_mutex_lock ((pthread_mutex_t *)*lock);
+}
+
+static int gcry_thread_mutex_unlock (void **lock)
+{
+ return pthread_mutex_unlock ((pthread_mutex_t *)*lock);
+}
+
+static struct gcry_thread_cbs gcry_threads = {
+ GCRY_THREAD_OPTION_PTHREAD, NULL,
+ gcry_thread_mutex_init, gcry_thread_mutex_destroy,
+ gcry_thread_mutex_lock, gcry_thread_mutex_unlock
+};
+
+#else
+static int gcry_thread_mutex_init (void **priv)
+{
+ int err = 0;
+ CRITICAL_SECTION *lock = (CRITICAL_SECTION *)malloc(sizeof(CRITICAL_SECTION));
+ if (!lock)
+ err = ENOMEM;
+ if (!err) {
+ InitializeCriticalSection(lock);
+ *priv = lock;
+ }
+ return err;
+}
+
+static int gcry_thread_mutex_destroy (void **lock)
+{
+ free(*lock);
+ return 0;
+}
+
+static int gcry_thread_mutex_lock (void **lock)
+{
+ EnterCriticalSection((CRITICAL_SECTION *)*lock);
+ return 0;
+}
+
+static int gcry_thread_mutex_unlock (void **lock)
+{
+ LeaveCriticalSection((CRITICAL_SECTION *)*lock);
+ return 0;
+}
+
+static struct gcry_thread_cbs gcry_threads = {
+ GCRY_THREAD_OPTION_PTHREAD, NULL,
+ gcry_thread_mutex_init, gcry_thread_mutex_destroy,
+ gcry_thread_mutex_lock, gcry_thread_mutex_unlock
+};
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+int initializeGcrypt ()
+{
+
+ if (initialized) {
+ return 1;
+ }
+ gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads);
+ gcry_check_version(NULL);
+ gcry_control(GCRYCTL_DISABLE_SECMEM);
+ initialized = 1;
+ return 1;
+}
diff --git a/src/libzrtpcpp/crypto/gcrypt/gcryptAesCFB.cpp b/src/libzrtpcpp/crypto/gcrypt/gcryptAesCFB.cpp
new file mode 100644
index 0000000..3673619
--- /dev/null
+++ b/src/libzrtpcpp/crypto/gcrypt/gcryptAesCFB.cpp
@@ -0,0 +1,77 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/** Copyright (C) 2006, 2007
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <gcrypt.h>
+#include <libzrtpcpp/crypto/aesCFB.h>
+
+
+extern void initializeGcrypt();
+
+void aesCfbEncrypt(uint8_t* key, int32_t keyLength, uint8_t* IV, uint8_t *data,
+ int32_t dataLength)
+{
+ gcry_error_t err = 0;
+ int algo;
+
+ initializeGcrypt();
+
+ if (keyLength == 16) {
+ algo = GCRY_CIPHER_AES;
+ }
+ else if (keyLength == 32) {
+ algo = GCRY_CIPHER_AES256;
+ }
+ else {
+ return;
+ }
+ gcry_cipher_hd_t tmp;
+ err = gcry_cipher_open(&tmp, algo, GCRY_CIPHER_MODE_CFB, 0);
+ err = gcry_cipher_setkey(tmp, key, keyLength);
+ err = gcry_cipher_setiv (tmp, IV, AES_BLOCK_SIZE);
+ err = gcry_cipher_encrypt (tmp, data, dataLength, data, dataLength);
+ gcry_cipher_close(tmp);
+}
+
+void aesCfbDecrypt(uint8_t* key, int32_t keyLength, const uint8_t* IV, uint8_t *data,
+ int32_t dataLength)
+{
+ gcry_error_t err = 0;
+ int algo;
+
+ initializeGcrypt();
+
+ if (keyLength == 16) {
+ algo = GCRY_CIPHER_AES;
+ }
+ else if (keyLength == 32) {
+ algo = GCRY_CIPHER_AES256;
+ }
+ else {
+ return;
+ }
+ gcry_cipher_hd_t tmp;
+ err = gcry_cipher_open(&tmp, algo, GCRY_CIPHER_MODE_CFB, 0);
+ err = gcry_cipher_setkey(tmp, key, keyLength);
+ err = gcry_cipher_setiv (tmp, IV, AES_BLOCK_SIZE);
+ err = gcry_cipher_decrypt (tmp, data, dataLength, data, dataLength);
+ gcry_cipher_close(tmp);
+}
diff --git a/src/libzrtpcpp/crypto/gcrypt/gcryptZrtpDH.cpp b/src/libzrtpcpp/crypto/gcrypt/gcryptZrtpDH.cpp
new file mode 100644
index 0000000..1aba680
--- /dev/null
+++ b/src/libzrtpcpp/crypto/gcrypt/gcryptZrtpDH.cpp
@@ -0,0 +1,349 @@
+/*
+ Copyright (C) 2006, 2009 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/>.
+*/
+
+/** Copyright (C) 2006, 2009
+ *
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <gcrypt.h>
+#include <libzrtpcpp/crypto/ZrtpDH.h>
+#include <libzrtpcpp/ZrtpTextData.h>
+#include <sstream>
+
+struct gcryptCtx {
+ gcry_mpi_t privKey;
+ gcry_mpi_t pubKey;
+// int32_t pLength;
+};
+
+extern void initializeGcrypt();
+
+static gcry_mpi_t bnP2048 = NULL;
+static gcry_mpi_t bnP3072 = NULL;
+// static gcry_mpi_t bnP4096 = NULL;
+static gcry_mpi_t two = NULL;
+static gcry_mpi_t bnP2048MinusOne = NULL;
+static gcry_mpi_t bnP3072MinusOne = NULL;
+// static gcry_mpi_t bnP4096MinusOne = NULL;
+
+static uint8_t dhinit = 0;
+
+void randomZRTP(uint8_t *buf, int32_t length) {
+ initializeGcrypt();
+ gcry_randomize(buf, length, GCRY_STRONG_RANDOM);
+}
+
+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
+};
+ *************** */
+#define DH3K 1
+#define DH2K 0
+ZrtpDH::ZrtpDH(const char* type){
+
+ // 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 {
+ fprintf(stderr, "Unknown pubkey algo: %d\n", pkType);
+ }
+ ctx = static_cast<void*>(new gcryptCtx);
+ gcryptCtx* tmpCtx = static_cast<gcryptCtx*>(ctx);
+ tmpCtx->privKey = NULL;
+ tmpCtx->pubKey = NULL;
+
+ initializeGcrypt();
+
+ if (!dhinit) {
+ gcry_mpi_scan(&bnP2048, GCRYMPI_FMT_USG, P2048, sizeof(P2048), NULL);
+ gcry_mpi_scan(&bnP3072, GCRYMPI_FMT_USG, P3072, sizeof(P3072), NULL);
+// gcry_mpi_scan(&bnP4096, GCRYMPI_FMT_USG, P4096, sizeof(P4096), NULL);
+ two = gcry_mpi_set_ui(NULL, 2);
+
+ bnP2048MinusOne = gcry_mpi_new(sizeof(P2048)*8);
+ gcry_mpi_sub_ui(bnP2048MinusOne, bnP2048, 1);
+
+ bnP3072MinusOne = gcry_mpi_new(sizeof(P3072)*8);
+ gcry_mpi_sub_ui(bnP3072MinusOne, bnP3072, 1);
+
+// bnP4096MinusOne = gcry_mpi_new(sizeof(P4096)*8);
+// gcry_mpi_sub_ui(bnP4096MinusOne, bnP4096, 1);
+ dhinit = 1;
+ }
+
+ if (pkType == DH3K) {
+ tmpCtx->privKey = gcry_mpi_new(256);
+ gcry_mpi_randomize(tmpCtx->privKey, 256, GCRY_STRONG_RANDOM);
+ }
+ else if (pkType == DH2K) {
+ tmpCtx->privKey = gcry_mpi_new(512);
+ gcry_mpi_randomize(tmpCtx->privKey, 512, GCRY_STRONG_RANDOM);
+ }
+// else {
+// tmpCtx->privKey = gcry_mpi_new(512);
+// gcry_mpi_randomize(tmpCtx->privKey, 512, GCRY_STRONG_RANDOM);
+// }
+}
+
+ZrtpDH::~ZrtpDH() {
+ gcryptCtx* tmpCtx = static_cast<gcryptCtx*>(ctx);
+
+ if (tmpCtx != NULL) {
+ gcry_mpi_release(tmpCtx->privKey);
+ tmpCtx->privKey = NULL;
+ gcry_mpi_release(tmpCtx->pubKey);
+ tmpCtx->pubKey = NULL;
+ delete tmpCtx;
+ ctx = NULL;
+ }
+}
+
+int32_t ZrtpDH::computeSecretKey(uint8_t *pubKeyBytes, uint8_t *secret) {
+
+ int32_t length = getDhSize();
+ gcryptCtx* tmpCtx = static_cast<gcryptCtx*>(ctx);
+
+ gcry_mpi_t pubKeyOther;
+ gcry_mpi_t sec = gcry_mpi_new(0);
+ gcry_mpi_scan(&pubKeyOther, GCRYMPI_FMT_USG, pubKeyBytes, length, NULL);
+
+ if (pkType == DH2K) {
+ gcry_mpi_powm(sec, pubKeyOther, tmpCtx->privKey, bnP2048);
+ }
+ else if (pkType == DH3K) {
+ gcry_mpi_powm(sec, pubKeyOther, tmpCtx->privKey, bnP3072);
+ }
+ else {
+// gcry_mpi_powm(sec, pubKeyOther, tmpCtx->privKey, bnP4096);
+ return 0;
+ }
+ gcry_mpi_release(pubKeyOther);
+
+ size_t result;
+ gcry_mpi_print(GCRYMPI_FMT_USG, secret, length, &result, sec);
+ gcry_mpi_release(sec);
+
+ return result;
+}
+
+int32_t ZrtpDH::generatePublicKey()
+{
+ gcryptCtx* tmpCtx = static_cast<gcryptCtx*>(ctx);
+
+ tmpCtx->pubKey = gcry_mpi_new(0);
+ if (pkType == DH2K) {
+ gcry_mpi_powm(tmpCtx->pubKey, two, tmpCtx->privKey, bnP2048);
+ }
+ else if (pkType == DH3K) {
+ gcry_mpi_powm(tmpCtx->pubKey, two, tmpCtx->privKey, bnP3072);
+ }
+ else {
+// gcry_mpi_powm(tmpCtx->pubKey, two, tmpCtx->privKey, bnP4096);
+ return 0;
+ }
+ return 1;
+}
+
+int32_t ZrtpDH::getPubKeyBytes(uint8_t *buf) const
+{
+ gcryptCtx* tmpCtx = static_cast<gcryptCtx*>(ctx);
+ int32_t len = getPubKeySize();
+
+ // get length of Dh in bytes, prepend buffer with zeros if necessary
+ int32_t prepend = getDhSize() - getPubKeySize();
+ if (prepend > 0) {
+ memset(buf, 0, prepend);
+ }
+ size_t i = 0;
+ gcry_mpi_print(GCRYMPI_FMT_USG, buf + prepend, len, &i, tmpCtx->pubKey);
+ return i;
+}
+
+int32_t ZrtpDH::getDhSize() const
+{
+ switch (pkType) {
+ case DH2K:
+ return 2048/8;
+ break;
+ case DH3K:
+ return 3072/8;
+ break;
+ }
+ return 0;
+}
+
+int32_t ZrtpDH::getPubKeySize() const
+{
+ return ((gcry_mpi_get_nbits(static_cast<gcryptCtx*>(ctx)->pubKey) + 7) / 8);
+}
+
+int32_t ZrtpDH::checkPubKey(uint8_t *pubKeyBytes) const
+{
+ gcry_mpi_t pubKeyOther = NULL;
+ gcry_mpi_scan(&pubKeyOther, GCRYMPI_FMT_USG, pubKeyBytes, getDhSize(), NULL);
+
+ if (pkType == DH2K) {
+ if (gcry_mpi_cmp(bnP2048MinusOne, pubKeyOther) == 0)
+ return 0;
+ }
+ else if (pkType == DH3K) {
+ if (gcry_mpi_cmp(bnP3072MinusOne, pubKeyOther) == 0)
+ return 0;
+ }
+ else {
+// if (gcry_mpi_cmp(bnP4096MinusOne, pubKeyOther) == 0)
+ return 0;
+ }
+ if (gcry_mpi_cmp_ui(pubKeyOther, 1) == 0) {
+ return 0;
+ }
+
+ gcry_mpi_release(pubKeyOther);
+ return 1;
+}
+
+const char* ZrtpDH::getDHtype()
+{
+ switch (pkType) {
+ case DH2K:
+ return dh2k;
+ break;
+ case DH3K:
+ return dh3k;
+ break;
+ }
+ return NULL;
+}
+
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-default-style: ellemtel
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/src/libzrtpcpp/crypto/gcrypt/gcrypthmac256.cpp b/src/libzrtpcpp/crypto/gcrypt/gcrypthmac256.cpp
new file mode 100644
index 0000000..3a44504
--- /dev/null
+++ b/src/libzrtpcpp/crypto/gcrypt/gcrypthmac256.cpp
@@ -0,0 +1,68 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/*
+ * Authors: Erik Eliasson <eliasson@it.kth.se>
+ * Johan Bilien <jobi@via.ecp.fr>
+ */
+
+#include <gcrypt.h>
+#include <libzrtpcpp/crypto/hmac256.h>
+
+void hmac_sha256(uint8_t* key, uint32_t keyLength,
+ uint8_t* data, int32_t dataLength,
+ uint8_t* mac, uint32_t* macLength)
+{
+ gcry_md_hd_t hd;
+ gcry_error_t err = 0;
+
+ err = gcry_md_open(&hd, GCRY_MD_SHA256, GCRY_MD_FLAG_HMAC);
+ gcry_md_setkey(hd, key, keyLength);
+
+ gcry_md_write (hd, data, dataLength);
+
+ uint8_t* p = gcry_md_read (hd, GCRY_MD_SHA256);
+ memcpy(mac, p, SHA256_DIGEST_LENGTH);
+ if (macLength != NULL) {
+ *macLength = SHA256_DIGEST_LENGTH;
+ }
+ gcry_md_close (hd);
+}
+
+void hmac_sha256( uint8_t* key, uint32_t keyLength,
+ uint8_t* dataChunks[],
+ uint32_t dataChunkLength[],
+ uint8_t* mac, uint32_t* macLength )
+{
+ gcry_md_hd_t hd;
+ gcry_error_t err = 0;
+
+ err = gcry_md_open(&hd, GCRY_MD_SHA256, GCRY_MD_FLAG_HMAC);
+ gcry_md_setkey(hd, key, keyLength);
+
+ while (*dataChunks) {
+ gcry_md_write (hd, *dataChunks, (uint32_t)(*dataChunkLength));
+ dataChunks++;
+ dataChunkLength++;
+ }
+ uint8_t* p = gcry_md_read (hd, GCRY_MD_SHA256);
+ memcpy(mac, p, SHA256_DIGEST_LENGTH);
+ if (macLength != NULL) {
+ *macLength = SHA256_DIGEST_LENGTH;
+ }
+ gcry_md_close (hd);
+}
diff --git a/src/libzrtpcpp/crypto/gcrypt/gcrypthmac384.cpp b/src/libzrtpcpp/crypto/gcrypt/gcrypthmac384.cpp
new file mode 100644
index 0000000..c48813c
--- /dev/null
+++ b/src/libzrtpcpp/crypto/gcrypt/gcrypthmac384.cpp
@@ -0,0 +1,68 @@
+/*
+ Copyright (C) 2006-2009 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/>.
+*/
+
+/*
+ * Authors: Erik Eliasson <eliasson@it.kth.se>
+ * Johan Bilien <jobi@via.ecp.fr>
+ */
+
+#include <gcrypt.h>
+#include <libzrtpcpp/crypto/hmac384.h>
+
+void hmac_sha384(uint8_t* key, uint32_t keyLength,
+ uint8_t* data, int32_t dataLength,
+ uint8_t* mac, uint32_t* macLength)
+{
+ gcry_md_hd_t hd;
+ gcry_error_t err = 0;
+
+ err = gcry_md_open(&hd, GCRY_MD_SHA384, GCRY_MD_FLAG_HMAC);
+ gcry_md_setkey(hd, key, keyLength);
+
+ gcry_md_write (hd, data, dataLength);
+
+ uint8_t* p = gcry_md_read (hd, GCRY_MD_SHA384);
+ memcpy(mac, p, SHA384_DIGEST_LENGTH);
+ if (macLength != NULL) {
+ *macLength = SHA384_DIGEST_LENGTH;
+ }
+ gcry_md_close (hd);
+}
+
+void hmac_sha384( uint8_t* key, uint32_t keyLength,
+ uint8_t* dataChunks[],
+ uint32_t dataChunkLength[],
+ uint8_t* mac, uint32_t* macLength )
+{
+ gcry_md_hd_t hd;
+ gcry_error_t err = 0;
+
+ err = gcry_md_open(&hd, GCRY_MD_SHA384, GCRY_MD_FLAG_HMAC);
+ gcry_md_setkey(hd, key, keyLength);
+
+ while (*dataChunks) {
+ gcry_md_write (hd, *dataChunks, (uint32_t)(*dataChunkLength));
+ dataChunks++;
+ dataChunkLength++;
+ }
+ uint8_t* p = gcry_md_read (hd, GCRY_MD_SHA384);
+ memcpy(mac, p, SHA384_DIGEST_LENGTH);
+ if (macLength != NULL) {
+ *macLength = SHA384_DIGEST_LENGTH;
+ }
+ gcry_md_close (hd);
+}
diff --git a/src/libzrtpcpp/crypto/gcrypt/gcryptsha256.cpp b/src/libzrtpcpp/crypto/gcrypt/gcryptsha256.cpp
new file mode 100644
index 0000000..0c32bd8
--- /dev/null
+++ b/src/libzrtpcpp/crypto/gcrypt/gcryptsha256.cpp
@@ -0,0 +1,89 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/**
+ * @author Erik Eliasson <eliasson@it.kth.se>
+ * Johan Bilien <jobi@via.ecp.fr>
+ * Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <gcrypt.h>
+#include <libzrtpcpp/crypto/sha256.h>
+
+void sha256(unsigned char* data, unsigned int dataLength,
+ unsigned char* mac)
+{
+ gcry_md_hash_buffer(GCRY_MD_SHA256, mac, data, dataLength);
+}
+
+void sha256(unsigned char* dataChunks[],
+ unsigned int dataChunkLength[],
+ unsigned char* mac)
+{
+ gcry_md_hd_t hd;
+ gcry_error_t err = 0;
+
+ err = gcry_md_open(&hd, GCRY_MD_SHA256, 0);
+ while (*dataChunks) {
+ gcry_md_write (hd, *dataChunks, (uint32_t)(*dataChunkLength));
+ dataChunks++;
+ dataChunkLength++;
+ }
+ uint8_t* p = gcry_md_read (hd, GCRY_MD_SHA256);
+ memcpy(mac, p, SHA256_DIGEST_LENGTH);
+ gcry_md_close (hd);
+}
+
+void* createSha256Context()
+{
+ gcry_error_t err = 0;
+ gcry_md_hd_t hd;
+
+ err = gcry_md_open(&hd, GCRY_MD_SHA256, 0);
+ return (void*)hd;
+}
+
+void closeSha256Context(void* ctx, unsigned char* digest)
+{
+ gcry_md_hd_t hd = (gcry_md_hd_t)ctx;
+
+ if (digest != NULL) {
+ uint8_t* p = gcry_md_read (hd, GCRY_MD_SHA256);
+ memcpy(digest, p, SHA256_DIGEST_LENGTH);
+ }
+ gcry_md_close (hd);
+}
+
+void sha256Ctx(void* ctx, unsigned char* data,
+ unsigned int dataLength)
+{
+ gcry_md_hd_t hd = (gcry_md_hd_t)ctx;
+
+ gcry_md_write (hd, data, dataLength);
+}
+
+void sha256Ctx(void* ctx, unsigned char* dataChunks[],
+ unsigned int dataChunkLength[])
+{
+ gcry_md_hd_t hd = (gcry_md_hd_t)ctx;
+
+ while (*dataChunks) {
+ gcry_md_write (hd, *dataChunks, (uint32_t)(*dataChunkLength));
+ dataChunks++;
+ dataChunkLength++;
+ }
+}
diff --git a/src/libzrtpcpp/crypto/gcrypt/gcryptsha384.cpp b/src/libzrtpcpp/crypto/gcrypt/gcryptsha384.cpp
new file mode 100644
index 0000000..19c8c5b
--- /dev/null
+++ b/src/libzrtpcpp/crypto/gcrypt/gcryptsha384.cpp
@@ -0,0 +1,89 @@
+/*
+ Copyright (C) 2006-2007 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/>.
+*/
+
+/**
+ * @author Erik Eliasson <eliasson@it.kth.se>
+ * Johan Bilien <jobi@via.ecp.fr>
+ * Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#include <gcrypt.h>
+#include <libzrtpcpp/crypto/sha384.h>
+
+void sha384(unsigned char* data, unsigned int dataLength,
+ unsigned char* mac)
+{
+ gcry_md_hash_buffer(GCRY_MD_SHA384, mac, data, dataLength);
+}
+
+void sha384(unsigned char* dataChunks[],
+ unsigned int dataChunkLength[],
+ unsigned char* mac)
+{
+ gcry_md_hd_t hd;
+ gcry_error_t err = 0;
+
+ err = gcry_md_open(&hd, GCRY_MD_SHA384, 0);
+ while (*dataChunks) {
+ gcry_md_write (hd, *dataChunks, (uint32_t)(*dataChunkLength));
+ dataChunks++;
+ dataChunkLength++;
+ }
+ uint8_t* p = gcry_md_read (hd, GCRY_MD_SHA384);
+ memcpy(mac, p, SHA384_DIGEST_LENGTH);
+ gcry_md_close (hd);
+}
+
+void* createSha384Context()
+{
+ gcry_error_t err = 0;
+ gcry_md_hd_t hd;
+
+ err = gcry_md_open(&hd, GCRY_MD_SHA384, 0);
+ return (void*)hd;
+}
+
+void closeSha384Context(void* ctx, unsigned char* digest)
+{
+ gcry_md_hd_t hd = (gcry_md_hd_t)ctx;
+
+ if (digest != NULL) {
+ uint8_t* p = gcry_md_read (hd, GCRY_MD_SHA384);
+ memcpy(digest, p, SHA384_DIGEST_LENGTH);
+ }
+ gcry_md_close (hd);
+}
+
+void sha384Ctx(void* ctx, unsigned char* data,
+ unsigned int dataLength)
+{
+ gcry_md_hd_t hd = (gcry_md_hd_t)ctx;
+
+ gcry_md_write (hd, data, dataLength);
+}
+
+void sha384Ctx(void* ctx, unsigned char* dataChunks[],
+ unsigned int dataChunkLength[])
+{
+ gcry_md_hd_t hd = (gcry_md_hd_t)ctx;
+
+ while (*dataChunks) {
+ gcry_md_write (hd, *dataChunks, (uint32_t)(*dataChunkLength));
+ dataChunks++;
+ dataChunkLength++;
+ }
+}
diff --git a/src/libzrtpcpp/crypto/hmac256.h b/src/libzrtpcpp/crypto/hmac256.h
new file mode 100644
index 0000000..f9110a6
--- /dev/null
+++ b/src/libzrtpcpp/crypto/hmac256.h
@@ -0,0 +1,96 @@
+/*
+ Copyright (C) 2006, 2005, 2004 Erik Eliasson, Johan Bilien, 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
+
+*/
+
+/**
+ * Methods to compute a SHA256 HMAC.
+ *
+ * @author Erik Eliasson <eliasson@it.kth.se>
+ * @author Johan Bilien <jobi@via.ecp.fr>
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#ifndef HMAC_SHA256_H
+#define HMAC_SHA256_H
+
+/**
+ * @file hmac256.h
+ * @brief Function that provide SHA256 HMAC support
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <stdint.h>
+
+#ifndef SHA256_DIGEST_LENGTH
+#define SHA256_DIGEST_LENGTH 32
+#endif
+
+/**
+ * Compute SHA256 HMAC.
+ *
+ * This functions takes one data chunk and computes its SHA256 HMAC.
+ *
+ * @param key
+ * The MAC key.
+ * @param key_length
+ * Lneght of the MAC key in bytes
+ * @param data
+ * Points to the data chunk.
+ * @param data_length
+ * Length of the data in bytes
+ * @param mac
+ * Points to a buffer that receives the computed digest. This
+ * buffer must have a size of at least 32 bytes (SHA256_DIGEST_LENGTH).
+ * @param mac_length
+ * Point to an integer that receives the length of the computed HMAC.
+ */
+void hmac_sha256( uint8_t* key, uint32_t key_length,
+ uint8_t* data, int32_t data_length,
+ uint8_t* mac, uint32_t* mac_length );
+
+/**
+ * Compute SHA256 HMAC over several data cunks.
+ *
+ * This functions takes several data chunk and computes the SHA256 HAMAC. It
+ * uses the openSSL HAMAC SHA256 implementation.
+ *
+ * @param key
+ * The MAC key.
+ * @param key_length
+ * Lneght of the MAC key in bytes
+ * @param data
+ * Points to an array of pointers that point to the data chunks. A NULL
+ * pointer in an array element terminates the data chunks.
+ * @param data_length
+ * Points to an array of integers that hold the length of each data chunk.
+ * @param mac
+ * Points to a buffer that receives the computed digest. This
+ * buffer must have a size of at least 32 bytes (SHA256_DIGEST_LENGTH).
+ * @param mac_length
+ * Point to an integer that receives the length of the computed HMAC.
+ */
+
+void hmac_sha256( uint8_t* key, uint32_t key_length,
+ uint8_t* data[], uint32_t data_length[],
+ uint8_t* mac, uint32_t* mac_length );
+/**
+ * @}
+ */
+#endif
diff --git a/src/libzrtpcpp/crypto/hmac384.h b/src/libzrtpcpp/crypto/hmac384.h
new file mode 100644
index 0000000..223444a
--- /dev/null
+++ b/src/libzrtpcpp/crypto/hmac384.h
@@ -0,0 +1,96 @@
+/*
+ Copyright (C) 2009, 2006, 2005, 2004 Erik Eliasson, Johan Bilien, 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
+
+*/
+
+/**
+ * Methods to compute a SHA384 HMAC.
+ *
+ * @author Erik Eliasson <eliasson@it.kth.se>
+ * @author Johan Bilien <jobi@via.ecp.fr>
+ * @author Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#ifndef HMAC_SHA384_H
+#define HMAC_SHA384_H
+
+/**
+ * @file hmac384.h
+ * @brief Function that provide SHA384 HMAC support
+ *
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <stdint.h>
+
+#ifndef SHA384_DIGEST_LENGTH
+#define SHA384_DIGEST_LENGTH 48
+#endif
+
+/**
+ * Compute SHA384 HMAC.
+ *
+ * This functions takes one data chunk and computes its SHA384 HMAC.
+ *
+ * @param key
+ * The MAC key.
+ * @param key_length
+ * Lneght of the MAC key in bytes
+ * @param data
+ * Points to the data chunk.
+ * @param data_length
+ * Length of the data in bytes
+ * @param mac
+ * Points to a buffer that receives the computed digest. This
+ * buffer must have a size of at least 48 bytes (SHA384_DIGEST_LENGTH).
+ * @param mac_length
+ * Point to an integer that receives the length of the computed HMAC.
+ */
+void hmac_sha384( uint8_t* key, uint32_t key_length,
+ uint8_t* data, int32_t data_length,
+ uint8_t* mac, uint32_t* mac_length );
+
+/**
+ * Compute SHA384 HMAC over several data cunks.
+ *
+ * This functions takes several data chunk and computes the SHA384 HAMAC. It
+ * uses the openSSL HAMAC SHA384 implementation.
+ *
+ * @param key
+ * The MAC key.
+ * @param key_length
+ * Lneght of the MAC key in bytes
+ * @param data
+ * Points to an array of pointers that point to the data chunks. A NULL
+ * pointer in an array element terminates the data chunks.
+ * @param data_length
+ * Points to an array of integers that hold the length of each data chunk.
+ * @param mac
+ * Points to a buffer that receives the computed digest. This
+ * buffer must have a size of at least 48 bytes (SHA384_DIGEST_LENGTH).
+ * @param mac_length
+ * Point to an integer that receives the length of the computed HMAC.
+ */
+
+void hmac_sha384( uint8_t* key, uint32_t key_length,
+ uint8_t* data[], uint32_t data_length[],
+ uint8_t* mac, uint32_t* mac_length );
+/**
+ * @}
+ */
+#endif
diff --git a/src/libzrtpcpp/crypto/openssl/AesCFB.cpp b/src/libzrtpcpp/crypto/openssl/AesCFB.cpp
new file mode 100644
index 0000000..595d1ff
--- /dev/null
+++ b/src/libzrtpcpp/crypto/ope