ZRtp.h

Go to the documentation of this file.

/*
  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 _ZRTP_H_
#define _ZRTP_H_

#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/ZrtpCallback.h>
#include <libzrtpcpp/ZIDRecord.h>

#ifndef SHA256_DIGEST_LENGTH
#define SHA256_DIGEST_LENGTH 32
#endif


// The ZRTP error codes accroding the specification chapter 6.9
enum zrtpErrorCodes {
    MalformedPacket =   0x10,
    CriticalSWError =   0x20,
    UnsuppZRTPVersion = 0x30,
    HelloCompMismatch = 0x40,
    UnsuppHashType =    0x51,
    UnsuppCiphertype =  0x52,
    UnsuppPKExchange =  0x53,
    UnsuppSRTPAuthTag = 0x54,
    UnsuppSASScheme =   0x55,
    DHErrorWrongPV =    0x61,
    DHErrorWrongHVI =   0x62,
    ConfirmHMACWrong =  0x70,
    NonceReused =       0x80,
    EqualZIDHello =     0x90
};

class ZrtpStateClass;
class ZrtpDH;

class ZRtp {

    public:

        ZRtp(uint8_t* myZid, ZrtpCallback* cb);

        ~ZRtp();

        void startZrtpEngine();

        void stopZrtp();

        int32_t processZrtpMessage(uint8_t *extHeader);

        int32_t processTimeout();

        bool handleGoClear(uint8_t *extHeader);

        void setSigsSecret(uint8_t* data);

        void setSrtpsSecret(uint8_t* data);

        void setOtherSecret(uint8_t* data, int32_t length);

       void setClientId(std::string id);

       int32_t checkState(int32_t state);

       void SASVerified();

       void resetSASVerified();

 private:
     friend class ZrtpStateClass;

    ZrtpStateClass* stateEngine;

    uint8_t zid[12];

    uint8_t peerZid[12];

    ZrtpCallback* callback;

    ZrtpDH* dhContext;

    uint8_t* DHss;

    uint8_t pubKeyBytes[1024];
    int32_t pubKeyLen;
    Role myRole;

    std::string SAS;

    uint8_t sasValue[8];
    uint8_t rs1IDr[SHA256_DIGEST_LENGTH];
    uint8_t rs2IDr[SHA256_DIGEST_LENGTH];
    uint8_t sigsIDr[SHA256_DIGEST_LENGTH];
    uint8_t srtpsIDr[SHA256_DIGEST_LENGTH];
    uint8_t otherSecretIDr[SHA256_DIGEST_LENGTH];

    uint8_t rs1IDi[SHA256_DIGEST_LENGTH];
    uint8_t rs2IDi[SHA256_DIGEST_LENGTH];
    uint8_t sigsIDi[SHA256_DIGEST_LENGTH];
    uint8_t srtpsIDi[SHA256_DIGEST_LENGTH];
    uint8_t otherSecretIDi[SHA256_DIGEST_LENGTH];
    uint8_t hvi[SHA256_DIGEST_LENGTH];

    uint8_t peerHvi[SHA256_DIGEST_LENGTH];

    void* msgShaContext;
    SupportedHashes hash;
    SupportedSymCiphers cipher;
    SupportedPubKeys pubKey;
    SupportedSASTypes sasType;

    SupportedAuthLengths authLength;
    uint8_t messageHash[SHA256_DIGEST_LENGTH];
    uint8_t s0[SHA256_DIGEST_LENGTH];

    uint8_t newRs1[RS_LENGTH];

    uint8_t hmacKeyI[SHA256_DIGEST_LENGTH];
    uint8_t hmacKeyR[SHA256_DIGEST_LENGTH];

    uint8_t srtpKeyI[SHA256_DIGEST_LENGTH];
    uint8_t srtpSaltI[SHA256_DIGEST_LENGTH];

    uint8_t srtpKeyR[SHA256_DIGEST_LENGTH];
    uint8_t srtpSaltR[SHA256_DIGEST_LENGTH];

    uint8_t zrtpKeyI[SHA256_DIGEST_LENGTH];
    uint8_t zrtpKeyR[SHA256_DIGEST_LENGTH];

    ZrtpPacketHello    zrtpHello;
    ZrtpPacketHelloAck zrtpHelloAck;
    ZrtpPacketConf2Ack zrtpConf2Ack;
    ZrtpPacketClearAck zrtpClearAck;
    ZrtpPacketGoClear  zrtpGoClear;
    ZrtpPacketError    zrtpError;
    ZrtpPacketErrorAck zrtpErrorAck;

    ZrtpPacketDHPart* zpDH2;

    uint8_t randomIV[16];
    SupportedHashes findBestHash(ZrtpPacketHello *hello);

    SupportedSymCiphers findBestCipher(ZrtpPacketHello *hello);

    SupportedPubKeys findBestPubkey(ZrtpPacketHello *hello);

    SupportedSASTypes findBestSASType(ZrtpPacketHello *hello);

    SupportedAuthLengths findBestAuthLen(ZrtpPacketHello *hello);

    void computeHvi(ZrtpPacketDHPart* dh, ZrtpPacketHello *hello);

    void computeSharedSecretSet(ZIDRecord& zidRec);

    void computeSRTPKeys();

    void generateS0Initiator(ZrtpPacketDHPart *dhPart, ZIDRecord& zidRec);

    void generateS0Responder(ZrtpPacketDHPart *dhPart, ZIDRecord& zidRec);

    /*
     * The following methods are helper functions for ZrtpStateClass.
     * ZrtpStateClass calls them to prepare packets, send data, report
     * problems, etc.
     */
    int32_t sendPacketZRTP(ZrtpPacketBase *packet);

    int32_t activateTimer(int32_t tm) {return (callback->activateTimer(tm)); }

    int32_t cancelTimer() {return (callback->cancelTimer()); }

    ZrtpPacketHello *prepareHello() {return &zrtpHello; }

    ZrtpPacketHelloAck *prepareHelloAck() {
        return &zrtpHelloAck;
    }

    ZrtpPacketCommit *prepareCommit(ZrtpPacketHello *hello, uint32_t* errMsg);

    ZrtpPacketDHPart *prepareDHPart1(ZrtpPacketCommit *commit, uint32_t* errMsg);

    ZrtpPacketDHPart *prepareDHPart2(ZrtpPacketDHPart* dhPart1, uint32_t* errMsg);

    ZrtpPacketConfirm *prepareConfirm1(ZrtpPacketDHPart* dhPart2, uint32_t* errMsg);

    ZrtpPacketConfirm* prepareConfirm2(ZrtpPacketConfirm* confirm1, uint32_t* errMsg);

    ZrtpPacketConf2Ack* prepareConf2Ack(ZrtpPacketConfirm* confirm2, uint32_t* errMsg);

    ZrtpPacketErrorAck* prepareErrorAck(ZrtpPacketError* epkt);

    ZrtpPacketError* prepareError(uint32_t errMsg);

    ZrtpPacketClearAck* prepareClearAck(ZrtpPacketGoClear* gpkt);

    ZrtpPacketGoClear* prepareGoClear(uint32_t errMsg = 0);

    int32_t compareHvi(ZrtpPacketCommit *commit) {
        return (memcmp(hvi, commit->getHvi(), SHA256_DIGEST_LENGTH)); };

    void sendInfo(MessageSeverity severity, char* msg) {
        callback->sendInfo(severity, msg);
    }

    void zrtpNegotiationFailed(MessageSeverity severity, char* msg) {
        callback->zrtpNegotiationFailed(severity, msg);
    }

    void zrtpNotSuppOther() {
        callback->zrtpNotSuppOther();
    }

    bool srtpSecretsReady(EnableSecurity part);

    void srtpSecretsOff(EnableSecurity part);
};

#endif // ZRTP

---

© sourcejam.com 2005-2008