cypher.h

Go to the documentation of this file.

/*
 * cypher.h
 *
 * Encryption support classes.
 *
 * Portable Windows Library
 *
 * Copyright (c) 1993-2002 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Contributor(s): ______________________________________.
 */


#ifndef PTLIB_CYPHER_H
#define PTLIB_CYPHER_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#if P_CYPHER

class PSASLString : public PString
{
    PCLASSINFO(PSASLString, PString);
  public:
    PSASLString() { }
    PSASLString(const char * str)    { AppendValidated(str); }
    PSASLString(const PString & str) { AppendValidated(str); }
    PSASLString(const PSASLString & str) : PString(str) { }

    PSASLString & operator=(char ch)                 { MakeEmpty(); AppendValidated(ch);  return *this; }
    PSASLString & operator=(wchar_t ch)              { MakeEmpty(); AppendValidated(ch);  return *this; }
    PSASLString & operator=(const char * str)        { MakeEmpty(); AppendValidated(str); return *this; }
    PSASLString & operator=(const PString & str)     { MakeEmpty(); AppendValidated(str); return *this; }
    PSASLString & operator=(const PSASLString & str) { PString::operator=(str);           return *this; }

    PSASLString & operator+=(char ch)                 { AppendValidated(ch);     return *this; }
    PSASLString & operator+=(wchar_t ch)              { AppendValidated(ch);     return *this; }
    PSASLString & operator+=(const char * str)        { AppendValidated(str);    return *this; }
    PSASLString & operator+=(const PString & str)     { AppendValidated(str);    return *this; }
    PSASLString & operator+=(const PSASLString & str) { PString::operator=(str); return *this; }

  protected:
    void AppendValidated(const char * str);
    void AppendValidated(wchar_t ch);
};


class PBase64 : public PObject
{
  PCLASSINFO(PBase64, PObject);

  public:
    enum Options {
      e_CRLF, 
      e_LF,   
      e_NoLF, 
      e_URL   
    };

    explicit PBase64(
      Options options = e_CRLF,  
      PINDEX width = 76          
    );

    void StartEncoding(
      Options options = e_CRLF,  
      PINDEX width = 76          
    );
    void StartEncoding(
      const char * endOfLine,  
      PINDEX width = 76        
    );
    void StartEncoding(
      bool useCRLFs,         
      PINDEX width = 76      
    ) { StartEncoding(useCRLFs ? e_CRLF : e_LF, width); }

    void ProcessEncoding(
      const PString & str      // String to be encoded
    );
    void ProcessEncoding(
      const char * cstr        // C String to be encoded
    );
    void ProcessEncoding(
      const PBYTEArray & data  // Data block to be encoded
    );
    void ProcessEncoding(
      const void * dataBlock,  // Pointer to data to be encoded
      PINDEX length            // Length of the data block.
    );

    PString GetEncodedString();

    PString CompleteEncoding();


    static PString Encode(
      const PString & str,    
      Options options = e_LF, 
      PINDEX width = 76       
    );
    static PString Encode(
      const PString & str,    
      const char * endOfLine, 
      PINDEX width = 76       
    );
    static PString Encode(
      const char * cstr,      
      Options options = e_LF, 
      PINDEX width = 76       
    );
    static PString Encode(
      const char * cstr,      
      const char * endOfLine, 
      PINDEX width = 76       
    );
    static PString Encode(
      const PBYTEArray & data, 
      Options options = e_LF,  
      PINDEX width = 76        
    );
    static PString Encode(
      const PBYTEArray & data, 
      const char * endOfLine,  
      PINDEX width = 76        
    );
    static PString Encode(
      const void * dataBlock,  
      PINDEX length,           
      Options options = e_LF,  
      PINDEX width = 76        
    );
    static PString Encode(
      const void * dataBlock,  
      PINDEX length,           
      const char * endOfLine,  
      PINDEX width = 76        
    );


    void StartDecoding();
    // Begin a base 64 decoding operation, initialising the object instance.

    PBoolean ProcessDecoding(
      const PString & str      // String to be encoded
    );
    PBoolean ProcessDecoding(
      const char * cstr        // C String to be encoded
    );

    PBoolean GetDecodedData(
      void * dataBlock,    // Pointer to data to be decoded from base64
      PINDEX length        // Length of the data block.
    );
    PBYTEArray GetDecodedData();

    PBoolean IsDecodeOK() { return m_perfectDecode; }


    static PString Decode(
      const PString & str // Encoded base64 string to be decoded.
    );
    static PBoolean Decode(
      const PString & str, // Encoded base64 string to be decoded.
      PBYTEArray & data    // Converted binary data from base64.
    );
    static PBoolean Decode(
      const PString & str, // Encoded base64 string to be decoded.
      void * dataBlock,    // Pointer to data to be decoded from base64
      PINDEX length        // Length of the data block.
    );



  private:
    void OutputBase64(const BYTE * data);

    PString m_encodedString;
    BYTE    m_saveTriple[3];
    PINDEX  m_saveCount;
    PString m_endOfLine;
    PINDEX  m_maxLineLength;
    PINDEX  m_currentLineLength;
    const char * m_alphabet;

    bool       m_perfectDecode;
    PINDEX     m_quadPosition;
    PBYTEArray m_decodedData;
    PINDEX     m_decodeSize;
};


class PMessageDigest : public PObject
{
    PCLASSINFO(PMessageDigest, PObject)
  public:
    PMessageDigest();

    class Result : public PBYTEArray {
      public:
        virtual void PrintOn(ostream & strm) const;

        bool ConstantTimeCompare(const Result & other) const;

        PString AsBase64(PBase64::Options options = PBase64::e_NoLF) const { return PBase64::Encode(*this, options); }
        PString AsHex() const;
    };

    void Start() { InternalStart(); }

    void Process(
      const void * dataBlock,  
      PINDEX length            
    );

    void Process(
      const PString & str      
    );
    void Process(
      const char * cstr        
    );
    void Process(
      const PBYTEArray & data  
    );

    PString Complete();
    void Complete(
      Result & result   
    ) { InternalCompleteDigest(result); }

  protected:
    virtual void InternalStart() = 0;
    virtual void InternalProcess(const void * dataBlock, PINDEX length) = 0;
    virtual void InternalCompleteDigest(Result & result) = 0;
};


template <class Digestor> struct PMessageDigestStatics
{
    static PString Encode(
      const PString & str      
    ) { return Encode(str.GetPointer(), str.GetLength()); }

    static void Encode(
      const PString & str,            
      PMessageDigest::Result & result 
    ) { Encode(str.GetPointer(), str.GetLength(), result); }

    static PString Encode(
      const char * cstr        
    ) { return Encode(cstr, (PINDEX)strlen(cstr)); }

    static void Encode(
      const char * cstr,       
      PMessageDigest::Result & result            
    ) { Encode(cstr, (PINDEX)strlen(cstr), result); }

    static PString Encode(
      const PBYTEArray & data  
    ) { return Encode(data, data.GetSize()); }

    static void Encode(
      const PBYTEArray & data, 
      PMessageDigest::Result & result            
    ) { Encode(data, data.GetSize(), result); }

    static PString Encode(
      const void * dataBlock,  
      PINDEX length            
    ) {
      PMessageDigest::Result result;
      Encode(dataBlock, length, result);
      return result.AsBase64();
    }

    static void Encode(
      const void * dataBlock,  
      PINDEX length,           
      PMessageDigest::Result & result            
    ) {
      Digestor stomach;
      stomach.Process(dataBlock, length);
      stomach.Complete(result);
    }
};


class PHMAC : public PObject
{
    PCLASSINFO(PHMAC, PObject);
  public:
    void SetKey(const char * key)             { InitKey(key, strlen(key)); }
    void SetKey(const PString & key)          { InitKey(key.GetPointer(), key.GetLength()); }
    void SetKey(const PBYTEArray & key)       { InitKey((const BYTE *)key, key.GetSize()); }
    void SetKey(const BYTE * key, PINDEX len) { InitKey(key, len); }

    PString Encode(const void * data, PINDEX len, PBase64::Options options = PBase64::e_NoLF);
    PString Encode(const PBYTEArray & data, PBase64::Options options = PBase64::e_NoLF);
    PString Encode(const PString & str, PBase64::Options options = PBase64::e_NoLF);

    typedef PMessageDigest::Result Result;
    virtual void Process(const void * data, PINDEX len, Result & result);
    virtual void Process(const PBYTEArray & data, Result & result);
    virtual void Process(const PString & str, Result & result);

  protected:
    virtual void InitKey(const void * key, PINDEX len);
    virtual void InternalProcess(const void * data, PINDEX len, PHMAC::Result & result) = 0;

    PBYTEArray m_key;
};


class PMessageDigest5 : public PMessageDigest, public PMessageDigestStatics<PMessageDigest5>
{
    PCLASSINFO(PMessageDigest5, PMessageDigest)
  public:
    enum { DigestLength = 16 };
    typedef PMessageDigest::Result Code; // Backward compatibility

    PMessageDigest5();

  protected:
    virtual void InternalStart();
    virtual void InternalProcess(const void * dataBlock, PINDEX length);
    virtual void InternalCompleteDigest(Result & result);

  private:
    void Transform(const BYTE * block);

    BYTE buffer[64];
    DWORD state[4];
    PUInt64 count;
};


class PHMAC_MD5 : public PHMAC
{
    PCLASSINFO(PHMAC_MD5, PHMAC)
  public:
    enum { BlockSize = 64 };

  protected:
    virtual void InitKey(const void * key, PINDEX len);
    virtual void InternalProcess(const void * data, PINDEX len, PHMAC::Result & result);
};


#if P_SSL

class PMessageDigestSHA : public PMessageDigest
{
    PCLASSINFO(PMessageDigestSHA, PMessageDigest)
  public:
    struct Context;

  protected:
    explicit PMessageDigestSHA(Context * context);

  public:
    ~PMessageDigestSHA();

  protected:
    virtual void InternalStart();
    virtual void InternalProcess(const void * dataBlock, PINDEX length);
    virtual void InternalCompleteDigest(Result & result);
    void Failed();

    Context * m_context;
    enum {
      e_Uninitialised,
      e_Processing,
      e_Failed
    } m_state;

  private:
    PMessageDigestSHA(const PMessageDigestSHA &) : m_context(), m_state() { }
    void operator=(const PMessageDigestSHA &) { }
};


class PMessageDigestSHA1 : public PMessageDigestSHA, public PMessageDigestStatics<PMessageDigestSHA1>
{
    PCLASSINFO(PMessageDigestSHA1, PMessageDigestSHA)
  public:
    enum { DigestLength = 20 };
    PMessageDigestSHA1();
};


class PMessageDigestSHA256 : public PMessageDigestSHA, public PMessageDigestStatics<PMessageDigestSHA256>
{
    PCLASSINFO(PMessageDigestSHA256, PMessageDigestSHA)
  public:
    PMessageDigestSHA256();
};


class PMessageDigestSHA384 : public PMessageDigestSHA, public PMessageDigestStatics<PMessageDigestSHA384>
{
    PCLASSINFO(PMessageDigestSHA384, PMessageDigestSHA)
  public:
    PMessageDigestSHA384();
};


class PMessageDigestSHA512 : public PMessageDigestSHA, public PMessageDigestStatics<PMessageDigestSHA512>
{
    PCLASSINFO(PMessageDigestSHA512, PMessageDigestSHA)
  public:
    PMessageDigestSHA512();
};


class PHMAC_SHA : public PHMAC
{
    PCLASSINFO(PHMAC_SHA, PHMAC)
  protected:
    typedef struct evp_md_st const * Algorithm;

    explicit PHMAC_SHA(Algorithm algo);
    virtual void InternalProcess(const void * data, PINDEX len, PHMAC::Result & result);

    Algorithm m_algorithm;
};


class PHMAC_SHA1 : public PHMAC_SHA
{
    PCLASSINFO(PHMAC_SHA1, PHMAC_SHA)
  public:
    PHMAC_SHA1();
};


class PHMAC_SHA256 : public PHMAC_SHA
{
    PCLASSINFO(PHMAC_SHA256, PHMAC_SHA)
  public:
    PHMAC_SHA256();
};


class PHMAC_SHA384 : public PHMAC_SHA
{
    PCLASSINFO(PHMAC_SHA384, PHMAC_SHA)
  public:
    PHMAC_SHA384();
};


class PHMAC_SHA512 : public PHMAC_SHA
{
    PCLASSINFO(PHMAC_SHA512, PHMAC_SHA)
  public:
    PHMAC_SHA512();
};

#endif // P_SSL


class PCypher : public PObject
{
  PCLASSINFO(PCypher, PObject)

  public:
    enum BlockChainMode {
      ElectronicCodebook,
        ECB = ElectronicCodebook,
      CypherBlockChaining,
        CBC = CypherBlockChaining,
      OutputFeedback,
        OFB = OutputFeedback,
      CypherFeedback,
        CFB = CypherFeedback,
      NumBlockChainModes
    };

  // New functions for class
    PString Encode(
      const PString & str       
    );
    PString Encode(
      const PBYTEArray & clear  
    );
    PString Encode(
      const void * data,        
      PINDEX length             
    );
    void Encode(
      const PBYTEArray & clear, 
      PBYTEArray & coded        
    );
    void Encode(
      const void * data,        // Clear text binary data to be encoded.
      PINDEX length,            // Number of bytes of data to be encoded.
      PBYTEArray & coded        // Encoded data.
    );

    PString Decode(
      const PString & cypher   
    );
    PBoolean Decode(
      const PString & cypher,  
      PString & clear          
    );
    PBoolean Decode(
      const PString & cypher,  
      PBYTEArray & clear       
    );
    PINDEX Decode(
      const PString & cypher,  
      void * data,             
      PINDEX length            
    );
    PINDEX Decode(
      const PBYTEArray & coded, 
      void * data,              
      PINDEX length             
    );
    PBoolean Decode(
      const PBYTEArray & coded, 
      PBYTEArray & clear       
    );


  protected:
    PCypher(
      PINDEX blockSize,          
      BlockChainMode chainMode   
    );
    PCypher(
      const void * keyData,    
      PINDEX keyLength,        
      PINDEX blockSize,        
      BlockChainMode chainMode 
    );


    virtual void Initialise(
      PBoolean encoding   
    ) = 0;

    virtual void EncodeBlock(
      const void * in,    
      void * out          
    ) = 0;


    virtual void DecodeBlock(
      const void * in,  
      void * out        
    ) = 0;


    PBYTEArray key;
    PINDEX blockSize;
    BlockChainMode chainMode;
};


class PTEACypher : public PCypher
{
  PCLASSINFO(PTEACypher, PCypher)

  public:
    struct Key {
      BYTE value[16];
    };

    PTEACypher(
      BlockChainMode chainMode = ElectronicCodebook   
    );
    PTEACypher(
      const Key & keyData,     
      BlockChainMode chainMode = ElectronicCodebook   
    );


    void SetKey(
      const Key & newKey    
    );

    void GetKey(
      Key & newKey    
    ) const;


    static void GenerateKey(
      Key & newKey    
    );


  protected:
    virtual void Initialise(
      PBoolean encoding   
    );

    virtual void EncodeBlock(
      const void * in,  
      void * out        
    );

    virtual void DecodeBlock(
      const void * in,  
      void * out        
    );

  private:
    DWORD k0, k1, k2, k3;
};


#ifdef P_CONFIG_FILE

class PSecureConfig : public PConfig
{
  PCLASSINFO(PSecureConfig, PConfig)
/* This class defines a set of configuration keys which may be secured by an
   encrypted hash function. Thus values contained in keys specified by this
   class cannot be changed without invalidating the hash function.
 */

  public:
    PSecureConfig(
      const PTEACypher::Key & productKey,    // Key to decrypt validation code.
      const PStringArray    & securedKeys,   // List of secured keys.
      Source src = Application        // Standard source for the configuration.
    );
    PSecureConfig(
      const PTEACypher::Key & productKey,   // Key to decrypt validation code.
      const char * const * securedKeyArray, // List of secured keys.
      PINDEX count,                         // Number of secured keys in list.
      Source src = Application        // Standard source for the configuration.
    );
    /* Create a secured configuration. The default section for the
       configuration keys is "Secured Options", the default security key is
       "Validation" and the defualt prefix string is "Pending:".

       The user can descend from this class and change any of the member
       variable for the names of keys or the configuration file section.
     */


  // New functions for class
    const PStringArray & GetSecuredKeys() const { return securedKeys; }
    /* Get the list of secured keys in the configuration file section.

       @return
       Array of  strings for the secured keys.
     */

    const PString & GetSecurityKey() const { return securityKey; }
    /* Get the security keys name in the configuration file section.

       @return
       String for the security values key.
     */

    const PString & GetExpiryDateKey() const { return expiryDateKey; }
    /* Get the expiry date keys name in the configuration file section.

       @return
       String for the expiry date values key.
     */

    const PString & GetOptionBitsKey() const { return optionBitsKey; }
    /* Get the Option Bits keys name in the configuration file section.

       @return
       String for the Option Bits values key.
     */

    const PString & GetPendingPrefix() const { return pendingPrefix; }
    /* Get the pending prefix name in the configuration file section.

       @return
       String for the pending prefix.
     */

    void GetProductKey(
      PTEACypher::Key & productKey  // Variable to receive the product key.
    ) const;
    /* Get the pending prefix name in the configuration file section.

       @return
       String for the pending prefix.
     */


    enum ValidationState {
      Defaults,
      Pending,
      IsValid,
      Expired,
      Invalid
    };
    ValidationState GetValidation() const;
    /* Check the current values attached to the keys specified in the
       constructor against an encoded validation key.

       @return
       State of the validation keys.
     */

    PBoolean ValidatePending();
    /* Validate a pending secured option list for the product. All secured
       keys with the <CODE>pendingPrefix</CODE> name will be checked against
       the value of the field <CODE>securityKey</CODE>. If they match then
       they are copied to the secured variables.

       @return
       true if secure key values are valid.
     */

    void ResetPending();
    /* "Unvalidate" a security configuration going back to a pending state,
       usually used after an <CODE>Invalid</CODE> response was recieved from
       the <A>GetValidation()</A> function.
     */


  protected:
    PTEACypher::Key productKey;
    PStringArray    securedKeys;
    PString         securityKey;
    PString         expiryDateKey;
    PString         optionBitsKey;
    PString         pendingPrefix;
};

#endif // P_CONFIG_FILE

#endif // P_CYPHER

#endif // PTLIB_CYPHER_H


// End Of File ///////////////////////////////////////////////////////////////