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): ______________________________________.
 *
 * $Revision: 31268 $
 * $Author: rjongbloed $
 * $Date: 2014-01-27 11:43:30 +1100 (Mon, 27 Jan 2014) $
 */


#ifndef PTLIB_CYPHER_H
#define PTLIB_CYPHER_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif


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

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

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

  protected:
    void Prepare(const char *);
    void AppendValidated(wchar_t c);
};


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

  public:
    PBase64();

    void StartEncoding(
      bool useCRLFs = true,  
      PINDEX width = 76      
    );
    void StartEncoding(
      const char * endOfLine,  
      PINDEX width = 76        
    );
    // Begin a base 64 encoding operation, initialising the object instance.

    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.
    );
    // Incorporate the specified data into the base 64 encoding.

    PString GetEncodedString();

    PString CompleteEncoding();


    static PString Encode(
      const PString & str,            
      const char * endOfLine = "\n",  
      PINDEX width = 76               
    );
    static PString Encode(
      const char * cstr,              
      const char * endOfLine = "\n",  
      PINDEX width = 76               
    );
    static PString Encode(
      const PBYTEArray & data,        
      const char * endOfLine = "\n",  
      PINDEX width = 76               
    );
    static PString Encode(
      const void * dataBlock,         
      PINDEX length,                  
      const char * endOfLine = "\n",  
      PINDEX width = 76               
    );
    // Encode the data in memory to Base 64 data returnin the string.


    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 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 encodedString;
    BYTE    saveTriple[3];
    PINDEX  saveCount;
    PString endOfLine;
    PINDEX  maxLineLength;
    PINDEX  currentLineLength;

    bool       perfectDecode;
    PINDEX     quadPosition;
    PBYTEArray decodedData;
    PINDEX     decodeSize;
};

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

  public:
    PMessageDigest();

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

        PString AsBase64() const { return PBase64::Encode(*this, ""); }
        PString AsHex() const;
    };

    virtual void Start() = 0;

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

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

    virtual PString CompleteDigest();
    virtual void CompleteDigest(
      Result & result   
    );

  protected:
    virtual void InternalProcess(
       const void * dataBlock,  
      PINDEX length            
    ) = 0;

    virtual void InternalCompleteDigest(
      Result & result   
    ) = 0;
};


class PHMAC : public PObject
{
  public:
    enum { KeyLength = 20 };
    enum { BlockSize = 64 };

    typedef PMessageDigest::Result Result;
    virtual void Hash(const BYTE * data, PINDEX len, Result & result) = 0;

    virtual PString Encode(const BYTE * data, PINDEX len);
    virtual PString Encode(const PBYTEArray & data);
    virtual PString Encode(const PString & str);

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

  protected:
    virtual PINDEX GetL() const { return KeyLength; };
    virtual PINDEX GetB() const { return BlockSize; }
    virtual void Initialise(const BYTE * key, PINDEX len);
    virtual void InternalProcess(const BYTE * data, PINDEX len, PHMAC::Result & result);

    PBYTEArray m_key;
};

template <class hash_class>
class PHMACTemplate : public PHMAC
{
  public:
    PHMACTemplate(const PString & key)                   { Initialise((const BYTE *)(const char *)key, key.GetLength()); }
    PHMACTemplate(const PBYTEArray & key)                { Initialise((const BYTE *)key, key.GetSize()); }
    PHMACTemplate(const BYTE * key, PINDEX len)          { Initialise(key, len); }

    virtual void Hash(const BYTE * data, PINDEX len, Result & result)
    { hash_class::Encode(data, len, result); }
};

class PMessageDigest5 : public PMessageDigest
{
  PCLASSINFO(PMessageDigest5, PMessageDigest)

  public:
    enum { DigestLength = 16 };

    PMessageDigest5();

    void Start();

    static PString Encode(
      const PString & str      
    );
    static void Encode(
      const PString & str,     
      Result & result            
    );
    static PString Encode(
      const char * cstr        
    );
    static void Encode(
      const char * cstr,       
      Result & result            
    );
    static PString Encode(
      const PBYTEArray & data  
    );
    static void Encode(
      const PBYTEArray & data, 
      Result & result            
    );
    static PString Encode(
      const void * dataBlock,  
      PINDEX length            
    );
    static void Encode(
      const void * dataBlock,  
      PINDEX length,           
      Result & result            
    );

    // backwards compatibility functions
    class Code {
      private:
        PUInt32l value[4];
        friend class PMessageDigest5;
    };

    static void Encode(
      const PString & str,     
      Code & result            
    );
    static void Encode(
      const char * cstr,       
      Code & result            
    );
    static void Encode(
      const PBYTEArray & data, 
      Code & result            
    );
    static void Encode(
      const void * dataBlock,  
      PINDEX length,           
      Code & result            
    );
    virtual void Complete(
      Code & result   
    );
    virtual PString Complete();

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

typedef PHMACTemplate<PMessageDigest5> PHMAC_MD5;

#if P_SSL

class PMessageDigestSHA1 : public PMessageDigest
{
  PCLASSINFO(PMessageDigestSHA1, PMessageDigest)

  public:
    enum { DigestLength = 20 };

    PMessageDigestSHA1();
    ~PMessageDigestSHA1();

    void Start();

    static PString Encode(
      const PString & str      
    );
    static void Encode(
      const PString & str,     
      Result & result            
    );
    static PString Encode(
      const char * cstr        
    );
    static void Encode(
      const char * cstr,       
      Result & result            
    );
    static PString Encode(
      const PBYTEArray & data  
    );
    static void Encode(
      const PBYTEArray & data, 
      Result & result            
    );
    static PString Encode(
      const void * dataBlock,  
      PINDEX length            
    );
    static void Encode(
      const void * dataBlock,  
      PINDEX length,           
      Result & result            
    );

  protected:
    virtual void InternalProcess(
       const void * dataBlock,  
      PINDEX length            
    );

    void InternalCompleteDigest(
      Result & result   
    );

  private:
    void * shaContext;
};

typedef PHMACTemplate<PMessageDigestSHA1> PHMAC_SHA1;

#endif

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


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