ZrtpCWrapper.h

Go to the documentation of this file.

/*
    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

#include <stdint.h>

/*
 * Keep the following defines in sync with Role enumeration in ZrtpCallback.h
 */
#define Responder 1             
#define Initiator 2             
#define CRC_SIZE  4             
#define ZRTP_MAGIC 0x5a525450   
#define MAX_ZRTP_SIZE 3072      
/*
 * 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 .
 */

enum zrtp_MessageSeverity {
    zrtp_Info = 1,                      
    zrtp_Warning,                       
    zrtp_Severe,                        
    zrtp_ZrtpError                      
};

enum zrtp_InfoCodes {
    zrtp_InfoHelloReceived = 1,          
    zrtp_InfoCommitDHGenerated,          
    zrtp_InfoRespCommitReceived,         
    zrtp_InfoDH1DHGenerated,             
    zrtp_InfoInitDH1Received,            
    zrtp_InfoRespDH2Received,            
    zrtp_InfoInitConf1Received,          
    zrtp_InfoRespConf2Received,          
    zrtp_InfoRSMatchFound,               
    zrtp_InfoSecureStateOn,              
    zrtp_InfoSecureStateOff              
};

enum zrtp_WarningCodes {
    zrtp_WarningDHAESmismatch = 1,       
    zrtp_WarningGoClearReceived,         
    zrtp_WarningDHShort,                 
    zrtp_WarningNoRSMatch,               
    zrtp_WarningCRCmismatch,             
    zrtp_WarningSRTPauthError,           
    zrtp_WarningSRTPreplayError,         
    zrtp_WarningNoExpectedRSMatch        
};

enum zrtp_SevereCodes {
    zrtp_SevereHelloHMACFailed = 1,      
    zrtp_SevereCommitHMACFailed,         
    zrtp_SevereDH1HMACFailed,            
    zrtp_SevereDH2HMACFailed,            
    zrtp_SevereCannotSend,               
    zrtp_SevereProtocolError,            
    zrtp_SevereNoTimer,                  
    zrtp_SevereTooMuchRetries            
};

enum zrtp_ZrtpErrorCodes {
    zrtp_MalformedPacket =   0x10,    
    zrtp_CriticalSWError =   0x20,    
    zrtp_UnsuppZRTPVersion = 0x30,    
    zrtp_HelloCompMismatch = 0x40,    
    zrtp_UnsuppHashType =    0x51,    
    zrtp_UnsuppCiphertype =  0x52,    
    zrtp_UnsuppPKExchange =  0x53,    
    zrtp_UnsuppSRTPAuthTag = 0x54,    
    zrtp_UnsuppSASScheme =   0x55,    
    zrtp_NoSharedSecret =    0x56,    
    zrtp_DHErrorWrongPV =    0x61,    
    zrtp_DHErrorWrongHVI =   0x62,    
    zrtp_SASuntrustedMiTM =  0x63,    
    zrtp_ConfirmHMACWrong =  0x70,    
    zrtp_NonceReused =       0x80,    
    zrtp_EqualZIDHello =     0x90,    
    zrtp_GoCleatNotAllowed = 0x100,   
    zrtp_IgnorePacket =      0x7fffffff 
};

enum zrtp_InfoEnrollment {
    zrtp_EnrollmentRequest,              
    zrtp_EnrollmentCanceled,             
    zrtp_EnrollmentFailed,               
    zrtp_EnrollmentOk                    
};

/* The ZRTP protocol states */
enum zrtpStates {
    Initial,            
    Detect,             
    AckDetected,        
    AckSent,            
    WaitCommit,         
    CommitSent,         
    WaitDHPart2,        
    WaitConfirm1,       
    WaitConfirm2,       
    WaitConfAck,        
    WaitClearAck,       
    SecureState,        
    WaitErrorAck,       
    numberOfStates      
};

typedef enum {
    zrtp_Aes = 1,        
    zrtp_TwoFish,        
    zrtp_Sha1,           
    zrtp_Skein           
} zrtp_SrtpAlgorithms;

typedef struct c_srtpSecrets
{
    zrtp_SrtpAlgorithms symEncAlgorithm;
    const uint8_t* keyInitiator;        
    int32_t initKeyLen;                 
    const uint8_t* saltInitiator;       
    int32_t initSaltLen;                
    const uint8_t* keyResponder;        
    int32_t respKeyLen;                 
    const uint8_t* saltResponder;       
    int32_t respSaltLen;                
    zrtp_SrtpAlgorithms authAlgorithm;  
    int32_t srtpAuthTagLen;             
    char* sas;                          
    int32_t  role;                      
} C_SrtpSecret_t;

/*
 * Keep the following defines in sync with enum EnableSecurity in ZrtpCallback.h
 */
#define ForReceiver 1       
#define ForSender   2       
#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;                   
        ZrtpCallbackWrapper* zrtpCallback;  
        ZrtpConfigure* configure;           
        void* userData;                     
    } ZrtpContext;

    typedef struct zrtp_Callbacks
    {
        int32_t (*zrtp_sendDataZRTP) (ZrtpContext* ctx, const uint8_t* data, int32_t length ) ;

        int32_t (*zrtp_activateTimer) (ZrtpContext* ctx, int32_t time ) ;

        int32_t (*zrtp_cancelTimer)(ZrtpContext* ctx) ;

        void (*zrtp_sendInfo) (ZrtpContext* ctx, int32_t severity, int32_t subCode ) ;

        int32_t (*zrtp_srtpSecretsReady) (ZrtpContext* ctx, C_SrtpSecret_t* secrets, int32_t part ) ;

        void (*zrtp_srtpSecretsOff) (ZrtpContext* ctx, int32_t part ) ;

        void (*zrtp_rtpSecretsOn) (ZrtpContext* ctx, char* c, char* s, int32_t verified ) ;

        void (*zrtp_handleGoClear)(ZrtpContext* ctx) ;

        void (*zrtp_zrtpNegotiationFailed) (ZrtpContext* ctx, int32_t severity, int32_t subCode ) ;

        void (*zrtp_zrtpNotSuppOther)(ZrtpContext* ctx) ;

        void (*zrtp_synchEnter)(ZrtpContext* ctx) ;

        void (*zrtp_synchLeave)(ZrtpContext* ctx) ;

        void (*zrtp_zrtpAskEnrollment) (ZrtpContext* ctx, int32_t info) ;

        void (*zrtp_zrtpInformEnrollment) (ZrtpContext* ctx, int32_t info ) ;

        void (*zrtp_signSAS)(ZrtpContext* ctx, uint8_t* sas) ;

        int32_t (*zrtp_checkSASSignature) (ZrtpContext* ctx, uint8_t* sas ) ;
    } zrtp_Callbacks;

    ZrtpContext* zrtp_CreateWrapper();

    void zrtp_initializeZrtpEngine(ZrtpContext* zrtpContext,
                                   zrtp_Callbacks *cb,
                                   const char* id,
                                   const char* zidFilename,
                                   void* userData,
                                   int32_t mitmMode);

    void zrtp_DestroyWrapper (ZrtpContext* zrtpContext);

    int32_t zrtp_CheckCksum(uint8_t* buffer, uint16_t length, uint32_t crc);

    uint32_t zrtp_GenerateCksum(uint8_t* buffer, uint16_t length);

    uint32_t zrtp_EndCksum(uint32_t crc);

    void zrtp_startZrtpEngine(ZrtpContext* zrtpContext);

    void zrtp_stopZrtpEngine(ZrtpContext* zrtpContext);

    void zrtp_processZrtpMessage(ZrtpContext* zrtpContext, uint8_t *extHeader, uint32_t peerSSRC);

    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);
    */
    
    void zrtp_setAuxSecret(ZrtpContext* zrtpContext, uint8_t* data, int32_t length);

    int32_t zrtp_inState(ZrtpContext* zrtpContext, int32_t state);

    void zrtp_SASVerified(ZrtpContext* zrtpContext);

    void zrtp_resetSASVerified(ZrtpContext* zrtpContext);

    char* zrtp_getHelloHash(ZrtpContext* zrtpContext);

    char* zrtp_getPeerHelloHash(ZrtpContext* zrtpContext);

    char* zrtp_getMultiStrParams(ZrtpContext* zrtpContext, int32_t *length);

    void zrtp_setMultiStrParams(ZrtpContext* zrtpContext, char* parameters, int32_t length);

    int32_t zrtp_isMultiStream(ZrtpContext* zrtpContext);

    int32_t zrtp_isMultiStreamAvailable(ZrtpContext* zrtpContext);

    void zrtp_acceptEnrollment(ZrtpContext* zrtpContext, int32_t accepted);

    int32_t zrtp_isEnrollmentMode(ZrtpContext* zrtpContext);

    void zrtp_setEnrollmentMode(ZrtpContext* zrtpContext, int32_t enrollmentMode);

    int32_t isPeerEnrolled(ZrtpContext* zrtpContext);

    int32_t zrtp_sendSASRelayPacket(ZrtpContext* zrtpContext, uint8_t* sh, char* render);

    const char* zrtp_getSasType(ZrtpContext* zrtpContext);
 
    uint8_t* zrtp_getSasHash(ZrtpContext* zrtpContext);

    int32_t zrtp_setSignatureData(ZrtpContext* zrtpContext, uint8_t* data, int32_t length);

    const uint8_t* zrtp_getSignatureData(ZrtpContext* zrtpContext);

    int32_t zrtp_getSignatureLength(ZrtpContext* zrtpContext);

    void zrtp_conf2AckSecure(ZrtpContext* zrtpContext);

    int32_t zrtp_getPeerZid(ZrtpContext* zrtpContext, uint8_t* data);


    /* 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;

    int32_t zrtp_InitializeConfig (ZrtpContext* zrtpContext);

    char** zrtp_getAlgorithmNames(ZrtpContext* zrtpContext, Zrtp_AlgoTypes type);

    void zrtp_freeAlgorithmNames(char** names);

    void zrtp_setStandardConfig(ZrtpContext* zrtpContext);

    void zrtp_setMandatoryOnly(ZrtpContext* zrtpContext);

    void zrtp_confClear(ZrtpContext* zrtpContext);

    int32_t zrtp_addAlgo(ZrtpContext* zrtpContext, Zrtp_AlgoTypes algoType, const char* algo);

    int32_t zrtp_addAlgoAt(ZrtpContext* zrtpContext, Zrtp_AlgoTypes algoType, const char* algo, int32_t index);

    int32_t zrtp_removeAlgo(ZrtpContext* zrtpContext, Zrtp_AlgoTypes algoType, const char* algo);

    int32_t zrtp_getNumConfiguredAlgos(ZrtpContext* zrtpContext, Zrtp_AlgoTypes algoType);

    const char* zrtp_getAlgoAt(ZrtpContext* zrtpContext, Zrtp_AlgoTypes algoType, int32_t index);

    int32_t zrtp_containsAlgo(ZrtpContext* zrtpContext, Zrtp_AlgoTypes algoType, const char*  algo);

    void zrtp_setTrustedMitM(ZrtpContext* zrtpContext, int32_t yesNo);

    int32_t zrtp_isTrustedMitM(ZrtpContext* zrtpContext);

    void zrtp_setSasSignature(ZrtpContext* zrtpContext, int32_t yesNo);

    int32_t zrtp_isSasSignature(ZrtpContext* zrtpContext);

#ifdef __cplusplus
}
#pragma GCC visibility pop
#endif

#endif