ZrtpConfigure.h

Go to the documentation of this file.

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

#include <stdio.h>
#include <stdint.h>
#include <list>
#include <string>
#include <vector>
#include <string.h>

#include <libzrtpcpp/ZrtpCallback.h>

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);

class AlgorithmEnum {
public:
    AlgorithmEnum(const AlgoTypes type, const char* name, int32_t klen,
                  const char* ra, encrypt_t en, decrypt_t de, SrtpAlgorithms alId);

    ~AlgorithmEnum();

    const char* getName();

    const char* getReadable();

    int getKeylen();

    SrtpAlgorithms getAlgoId();
    encrypt_t getEncrypt();

    decrypt_t getDecrypt();

    AlgoTypes getAlgoType();

    bool isValid();

private:
    AlgoTypes algoType;
    std::string algoName;
    int32_t   keyLen;
    std::string readable;
    encrypt_t encrypt;
    decrypt_t decrypt;
    SrtpAlgorithms   algoId;
};

class EnumBase {
public:
    AlgorithmEnum& getByName(const char* name);

    std::list<std::string>* getAllNames();

    int getSize();

    AlgoTypes getAlgoType();

    AlgorithmEnum& getByOrdinal(int ord);

    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;
};

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;

class __EXPORT ZrtpConfigure {
public:
    ZrtpConfigure();         /* Creates Configuration data */
    ~ZrtpConfigure();

    static const int maxNoOfAlgos = 7;
    void setStandardConfig();

    void setMandatoryOnly();

    void clear();

    int32_t addAlgo(AlgoTypes algoType, AlgorithmEnum& algo);

    int32_t addAlgoAt(AlgoTypes algoType, AlgorithmEnum& algo, int32_t index);

    int32_t removeAlgo(AlgoTypes algoType, AlgorithmEnum& algo);

    int32_t getNumConfiguredAlgos(AlgoTypes algoType);

    AlgorithmEnum& getAlgoAt(AlgoTypes algoType, int32_t index);

    bool containsAlgo(AlgoTypes algoType, AlgorithmEnum& algo);

    void setTrustedMitM(bool yesNo);

    bool isTrustedMitM();

    void setSasSignature(bool yesNo);

    bool isSasSignature();

    void setParanoidMode(bool yesNo);

    bool isParanoidMode();

    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