SecurityDefines.hpp

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch)
 *****************************************************************************
 * Project    : Zeus Base Library
 * Module     : SecurityDefines
 * Package    : Zeus.ZeusBase.Security
 * Author     : Benjamin Hadorn
 * Date       : 27.12.2011
 * System     : Zeus-Framework
 *****************************************************************************
 * Licence:                                                                  *
 *   This library is free software; you can redistribute it and/or modify    *
 *   it under the terms of the GNU Lesser General Public License as          *
 *   published by the Free Software Foundation; either version               *
 *   2.1 of the License, or (at your option) any later version.              *
 *                                                                           *
 *   This library 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 Lesser General Public License for more details.                     *
 *                                                                           *
 *   You should have received a copy of the GNU Lesser General Public        *
 *   License along with this library; if not, write to the Free Software     *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA    *
 *****************************************************************************/

/*****************************************************************************
 * Changes:
 *  27.12.2011 bha: created zeus 2.0
 *****************************************************************************/

#ifndef SecurityDefinesHPP
#define SecurityDefinesHPP

/**********************************************************************/
/**********************************************************************/
enum ECryptType
{
  etSimpleDES = 0, // Simple DES (not secure, just for demonstration purposes)
  etXTEA = 1       // eXtended Tiny Encryption Algorithm (pretty secure)
};


#define SHFR(x, n)    (x >> n)
#define ROTR(x, n)   ((x >> n) | (x << ((sizeof(x) << 3) - n)))
#define ROTL(x, n)   ((x << n) | (x >> ((sizeof(x) << 3) - n)))
#define CH(x, y, z)  ((x & y) ^ (~x & z))
#define MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))

//Packs 4 bytes into a 32bit value
//  [0][1][2][3] where as [3] represents the lowest 8 bits
#define PACK32(str, x)\
  {                                         \
    *(x) = ((Uint32) *((str) + 3))        | \
           ((Uint32) *((str) + 2) <<  8)  | \
           ((Uint32) *((str) + 1) << 16)  | \
           ((Uint32) *((str) + 0) << 24);   \
  }

//Unpacks a 32bit value into 4 bytes
// [0][1][2][3] where as [3] represents the lowest 8 bits
#define UNPACK32(x, str)                 \
  {                                      \
    *((str) + 3) = (Uint8) ((x));        \
    *((str) + 2) = (Uint8) ((x) >>  8);  \
    *((str) + 1) = (Uint8) ((x) >> 16);  \
    *((str) + 0) = (Uint8) ((x) >> 24);  \
  }

//Packs 8 bytes into a 64bit value
// [0][1][2][3][4][5][6][7] where as [7] represents the lowest 8 bits
#define PACK64(str, x)                       \
  {                                          \
    *(x) = ((Uint64) *((str) + 7)      )  |  \
           ((Uint64) *((str) + 6) <<  8)  |  \
           ((Uint64) *((str) + 5) << 16)  |  \
           ((Uint64) *((str) + 4) << 24)  |  \
           ((Uint64) *((str) + 3) << 32)  |  \
           ((Uint64) *((str) + 2) << 40)  |  \
           ((Uint64) *((str) + 1) << 48)  |  \
           ((Uint64) *((str) + 0) << 56);    \
  }

//Unpacks a 64bit value into 8 bytes
// [0][1][2][3][4][5][6][7] where as [7] represents the lowest 8 bits
#define UNPACK64(x, str)                    \
  {                                         \
    *((str) + 7) = (Uint8) ((x));           \
    *((str) + 6) = (Uint8) ((x) >>  8);     \
    *((str) + 5) = (Uint8) ((x) >> 16);     \
    *((str) + 4) = (Uint8) ((x) >> 24);     \
    *((str) + 3) = (Uint8) ((x) >> 32);     \
    *((str) + 2) = (Uint8) ((x) >> 40);     \
    *((str) + 1) = (Uint8) ((x) >> 48);     \
    *((str) + 0) = (Uint8) ((x) >> 56);     \
  }



#if defined(ZEUS_LITTLE_ENDIAN)

  #ifndef HOST_c2l
    #define HOST_c2l(c,l) (\
           l =(((Uint32)(*((c)++)))    ), \
           l|=(((Uint32)(*((c)++)))<< 8), \
           l|=(((Uint32)(*((c)++)))<<16), \
           l|=(((Uint32)(*((c)++)))<<24), \
           l)
  #endif
  #ifndef HOST_l2c
    #define HOST_l2c(l,c) (\
           *((c)++)=(Uint8)(((l)    )&0xff),  \
           *((c)++)=(Uint8)(((l)>> 8)&0xff),  \
           *((c)++)=(Uint8)(((l)>>16)&0xff),  \
           *((c)++)=(Uint8)(((l)>>24)&0xff),  \
           l)
  #endif

#else //defined(ZEUS_BIG_ENDIAN)
  #ifndef HOST_c2l
    #define HOST_c2l(c,l) (\
           l =(((Uint32)(*((c)++)))<<24), \
           l|=(((Uint32)(*((c)++)))<<16), \
           l|=(((Uint32)(*((c)++)))<< 8), \
           l|=(((Uint32)(*((c)++)))    ), \
           l)
  #endif

  #ifndef HOST_l2c
    #define HOST_l2c(l,c) (\
           *((c)++)=(Uint8)(((l)>>24)&0xff), \
           *((c)++)=(Uint8)(((l)>>16)&0xff), \
           *((c)++)=(Uint8)(((l)>> 8)&0xff), \
           *((c)++)=(Uint8)(((l)    )&0xff), \
           l)
  #endif
#endif //defined(ZEUS_BIG_ENDIAN)


//Swaps the bytes for big endian systems
#ifdef ZEUS_BIG_ENDIAN
  #define SWAP(n) (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))
#else
  #define SWAP(n) (n)
#endif

#endif