rvdesencryption.c

协议代码,主要用语Megaco 协议应用

/************************************************************************
 File Name     : rvdesencryption.c
 Description   :
*************************************************************************
 Copyright (c)  2001 , RADVision, Inc. All rights reserved.
*************************************************************************
 NOTICE:
 This document contains information that is proprietary to RADVision Inc. 
 No part of this publication may be reproduced in any form whatsoever
 without written prior approval by RADVision Inc. 
 
 RADVision Inc. reserves the right to revise this publication and make
 changes without obligation to notify any person of such revisions or
 changes.
*************************************************************************
 $Revision: $
 $Date:   03/13/2001 $
 $Author: Scott K. Eaton $
************************************************************************/

#include "rvdesencryption.h"


/***********************************************************************
 * Private data  
 ***********************************************************************/

/* Encryption mode */
#define RV_DESENCRYPTION_MODE_ECB 0  /* Electronic Codebook Mode   */
#define RV_DESENCRYPTION_MODE_CBC 1  /* Cipher Block Chaining Mode */

/* Offset to bit translation for RvUint16 skipping  */
static const RvUint16 bytebit[8] = 
{
	0200, 0100, 040, 020, 010, 04, 02, 01
};

/* Offset to bit translation for RvUint32 */
static const RvUint32 bigbyte[24] = 
{
	0x800000L,0x400000L,0x200000L,0x100000L,
	0x80000L ,0x40000L ,0x20000L ,0x10000L,
	0x8000L  ,0x4000L  ,0x2000L  ,0x1000L,
	0x800L   ,0x400L   ,0x200L   ,0x100L,
	0x80L    ,0x40L    ,0x20L    ,0x10L,
	0x8L     ,0x4L     ,0x2L     ,0x1L
};

static const RvUint8 keyRotation[16] = 
{
	1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28
};

/* Key Permutation */
static const RvUint8 keyPermutation[56] =   
{
	56,48,40,32,24,16,8 ,0 ,57,49,41,33,25,17,
	9 ,1 ,58,50,42,34,26,18,10,2 ,59,51,43,35,
	62,54,46,38,30,22,14,6 ,61,53,45,37,29,21,
	13,5 ,60,52,44,36,28,20,12,4 ,27,19,11,3
};

/* Compression Permutation */
static const RvUint8 compressionPermutation[48] =   
{
	13,16,10,23,0 ,4  ,2 ,27,14,5 ,20,9 ,
	22,18,11,3 ,25,7  ,15,6 ,26,19,12,1 ,
	40,51,30,36,46,54 ,29,39,50,44,32,47,
	43,48,38,55,33,52 ,45,41,49,35,28,31
};

/* S-Boxes */
static const RvUint32 SP1[64] = 
{
    0x01010400L,0x00000000L,0x00010000L,0x01010404L,
    0x01010004L,0x00010404L,0x00000004L,0x00010000L,
    0x00000400L,0x01010400L,0x01010404L,0x00000400L,
    0x01000404L,0x01010004L,0x01000000L,0x00000004L,
    0x00000404L,0x01000400L,0x01000400L,0x00010400L,
    0x00010400L,0x01010000L,0x01010000L,0x01000404L,
    0x00010004L,0x01000004L,0x01000004L,0x00010004L,
    0x00000000L,0x00000404L,0x00010404L,0x01000000L,
    0x00010000L,0x01010404L,0x00000004L,0x01010000L,
    0x01010400L,0x01000000L,0x01000000L,0x00000400L,
    0x01010004L,0x00010000L,0x00010400L,0x01000004L,
    0x00000400L,0x00000004L,0x01000404L,0x00010404L,
    0x01010404L,0x00010004L,0x01010000L,0x01000404L,
    0x01000004L,0x00000404L,0x00010404L,0x01010400L,
    0x00000404L,0x01000400L,0x01000400L,0x00000000L,
    0x00010004L,0x00010400L,0x00000000L,0x01010004L
};

static const RvUint32 SP2[64] = 
{
    0x80108020L,0x80008000L,0x00008000L,0x00108020L,
    0x00100000L,0x00000020L,0x80100020L,0x80008020L,
    0x80000020L,0x80108020L,0x80108000L,0x80000000L,
    0x80008000L,0x00100000L,0x00000020L,0x80100020L,
    0x00108000L,0x00100020L,0x80008020L,0x00000000L,
    0x80000000L,0x00008000L,0x00108020L,0x80100000L,
    0x00100020L,0x80000020L,0x00000000L,0x00108000L,
    0x00008020L,0x80108000L,0x80100000L,0x00008020L,
    0x00000000L,0x00108020L,0x80100020L,0x00100000L,
    0x80008020L,0x80100000L,0x80108000L,0x00008000L,
    0x80100000L,0x80008000L,0x00000020L,0x80108020L,
    0x00108020L,0x00000020L,0x00008000L,0x80000000L,
    0x00008020L,0x80108000L,0x00100000L,0x80000020L,
    0x00100020L,0x80008020L,0x80000020L,0x00100020L,
    0x00108000L,0x00000000L,0x80008000L,0x00008020L,
    0x80000000L,0x80100020L,0x80108020L,0x00108000L
};

static const RvUint32 SP3[64] = 
{
    0x00000208L,0x08020200L,0x00000000L,0x08020008L,
    0x08000200L,0x00000000L,0x00020208L,0x08000200L,
    0x00020008L,0x08000008L,0x08000008L,0x00020000L,
    0x08020208L,0x00020008L,0x08020000L,0x00000208L,
    0x08000000L,0x00000008L,0x08020200L,0x00000200L,
    0x00020200L,0x08020000L,0x08020008L,0x00020208L, 
    0x08000208L,0x00020200L,0x00020000L,0x08000208L, 
    0x00000008L,0x08020208L,0x00000200L,0x08000000L, 
    0x08020200L,0x08000000L,0x00020008L,0x00000208L, 
    0x00020000L,0x08020200L,0x08000200L,0x00000000L, 
    0x00000200L,0x00020008L,0x08020208L,0x08000200L, 
    0x08000008L,0x00000200L,0x00000000L,0x08020008L, 
    0x08000208L,0x00020000L,0x08000000L,0x08020208L, 
    0x00000008L,0x00020208L,0x00020200L,0x08000008L, 
    0x08020000L,0x08000208L,0x00000208L,0x08020000L, 
    0x00020208L,0x00000008L,0x08020008L,0x00020200L 
}; 

static const RvUint32 SP4[64] = 
{ 
    0x00802001L,0x00002081L,0x00002081L,0x00000080L,
    0x00802080L,0x00800081L,0x00800001L,0x00002001L,
    0x00000000L,0x00802000L,0x00802000L,0x00802081L, 
    0x00000081L,0x00000000L,0x00800080L,0x00800001L, 
    0x00000001L,0x00002000L,0x00800000L,0x00802001L, 
    0x00000080L,0x00800000L,0x00002001L,0x00002080L, 
    0x00800081L,0x00000001L,0x00002080L,0x00800080L, 
    0x00002000L,0x00802080L,0x00802081L,0x00000081L, 
    0x00800080L,0x00800001L,0x00802000L,0x00802081L, 
    0x00000081L,0x00000000L,0x00000000L,0x00802000L, 
    0x00002080L,0x00800080L,0x00800081L,0x00000001L, 
    0x00802001L,0x00002081L,0x00002081L,0x00000080L, 
    0x00802081L,0x00000081L,0x00000001L,0x00002000L, 
    0x00800001L,0x00002001L,0x00802080L,0x00800081L, 
    0x00002001L,0x00002080L,0x00800000L,0x00802001L, 
    0x00000080L,0x00800000L,0x00002000L,0x00802080L 
};

static const RvUint32 SP5[64] = 
{ 
    0x00000100L,0x02080100L,0x02080000L,0x42000100L, 
    0x00080000L,0x00000100L,0x40000000L,0x02080000L, 
    0x40080100L,0x00080000L,0x02000100L,0x40080100L, 
    0x42000100L,0x42080000L,0x00080100L,0x40000000L, 
    0x02000000L,0x40080000L,0x40080000L,0x00000000L, 
    0x40000100L,0x42080100L,0x42080100L,0x02000100L, 
    0x42080000L,0x40000100L,0x00000000L,0x42000000L,
    0x02080100L,0x02000000L,0x42000000L,0x00080100L, 
    0x00080000L,0x42000100L,0x00000100L,0x02000000L, 
    0x40000000L,0x02080000L,0x42000100L,0x40080100L, 
    0x02000100L,0x40000000L,0x42080000L,0x02080100L, 
    0x40080100L,0x00000100L,0x02000000L,0x42080000L, 
    0x42080100L,0x00080100L,0x42000000L,0x42080100L, 
    0x02080000L,0x00000000L,0x40080000L,0x42000000L, 
    0x00080100L,0x02000100L,0x40000100L,0x00080000L, 
    0x00000000L,0x40080000L,0x02080100L,0x40000100L 
}; 

static const RvUint32 SP6[64] = 
{ 
    0x20000010L,0x20400000L,0x00004000L,0x20404010L, 
    0x20400000L,0x00000010L,0x20404010L,0x00400000L, 
    0x20004000L,0x00404010L,0x00400000L,0x20000010L, 
    0x00400010L,0x20004000L,0x20000000L,0x00004010L, 
    0x00000000L,0x00400010L,0x20004010L,0x00004000L, 
    0x00404000L,0x20004010L,0x00000010L,0x20400010L, 
    0x20400010L,0x00000000L,0x00404010L,0x20404000L, 
    0x00004010L,0x00404000L,0x20404000L,0x20000000L, 
    0x20004000L,0x00000010L,0x20400010L,0x00404000L, 
    0x20404010L,0x00400000L,0x00004010L,0x20000010L, 
    0x00400000L,0x20004000L,0x20000000L,0x00004010L, 
    0x20000010L,0x20404010L,0x00404000L,0x20400000L, 
    0x00404010L,0x20404000L,0x00000000L,0x20400010L, 
    0x00000010L,0x00004000L,0x20400000L,0x00404010L, 
    0x00004000L,0x00400010L,0x20004010L,0x00000000L, 
    0x20404000L,0x20000000L,0x00400010L,0x20004010L 
};

static const RvUint32 SP7[64] = 
{ 
    0x00200000L,0x04200002L,0x04000802L,0x00000000L, 
    0x00000800L,0x04000802L,0x00200802L,0x04200800L, 
    0x04200802L,0x00200000L,0x00000000L,0x04000002L, 
    0x00000002L,0x04000000L,0x04200002L,0x00000802L, 
    0x04000800L,0x00200802L,0x00200002L,0x04000800L, 
    0x04000002L,0x04200000L,0x04200800L,0x00200002L, 
    0x04200000L,0x00000800L,0x00000802L,0x04200802L, 
    0x00200800L,0x00000002L,0x04000000L,0x00200800L, 
    0x04000000L,0x00200800L,0x00200000L,0x04000802L, 
    0x04000802L,0x04200002L,0x04200002L,0x00000002L, 
    0x00200002L,0x04000000L,0x04000800L,0x00200000L, 
    0x04200800L,0x00000802L,0x00200802L,0x04200800L, 
    0x00000802L,0x04000002L,0x04200802L,0x04200000L, 
    0x00200800L,0x00000000L,0x00000002L,0x04200802L, 
    0x00000000L,0x00200802L,0x04200000L,0x00000800L, 
    0x04000002L,0x04000800L,0x00000800L,0x00200002L 
}; 

static const RvUint32 SP8[64] = 
{ 
    0x10001040L,0x00001000L,0x00040000L,0x10041040L, 
    0x10000000L,0x10001040L,0x00000040L,0x10000000L, 
    0x00040040L,0x10040000L,0x10041040L,0x00041000L, 
    0x10041000L,0x00041040L,0x00001000L,0x00000040L, 
    0x10040000L,0x10000040L,0x10001000L,0x00001040L, 
    0x00041000L,0x00040040L,0x10040040L,0x10041000L, 
    0x00001040L,0x00000000L,0x00000000L,0x10040040L, 
    0x10000040L,0x10001000L,0x00041040L,0x00040000L, 
    0x00041040L,0x00040000L,0x10041000L,0x00001000L, 
    0x00000040L,0x10040040L,0x00001000L,0x00041040L, 
    0x10001000L,0x00000040L,0x10000040L,0x10040000L, 
    0x10040040L,0x10000000L,0x00040000L,0x10001040L, 
    0x00000000L,0x10041040L,0x00040040L,0x10000040L, 
    0x10040000L,0x10001000L,0x10001040L,0x00000000L, 
    0x10041040L,0x00041000L,0x00041000L,0x00001040L, 
    0x00001040L,0x00040040L,0x10000000L,0x10041000L 
}; 

/***********************************************************************
 * Private method declarations   
 ***********************************************************************/
static void rvDesEncryptionFunction(const RvUint8 *input, 
                RvUint8 *output, 
                RvUint32 length,
                RvUint8  mode,
                RvUint32 prevBlock[2],
                const RvUint32 keys[32],
                RvBool   encrypt);
static void rvDesEncryptionGenerateKeySet(const RvUint8 key[8], RvUint32 keys[32], RvBool encrypt);
static void rvDesEncryptionCookKeys( const RvUint32 keys[32], RvUint32 cookedKeys[32]);
static void rvDesEncryptionScrunch(const RvUint8 outof[8], RvUint32 into[2]);
static void rvDesEncryptionUnscrunch(const RvUint32 outof[2], RvUint8 into[8]);
static void rvDesEncryptionExpandKey(const RvUint8 key[7], RvUint8 expandedKey[8]);

/***********************************************************************
 * Public declarations   
 ***********************************************************************/
/*$
{function scope="protected":
	{name: rvDesEncryptionConstruct }
	{class: RvDesEncryption }
	{include: rvdesencryption.h}
	{description:
		{p: Default constructor. }
	}
	{proto: RvDesEncryption* rvDesEncryptionConstruct(RvDesEncryption* thisPtr);}
	{params:
		{param: {n: thisPtr} {d:The RvDesEncryption object to construct.}}
	}
	{returns: If successful a pointer to the object is returned, otherwise NULL.}
}
$*/
RvDesEncryption *rvDesEncryptionConstruct(RvDesEncryption *thisPtr)
{
    memset(thisPtr->iv,0,sizeof(thisPtr->iv));    
    memset(thisPtr->prevBlock,0,sizeof(thisPtr->prevBlock));    
    thisPtr->mode = RV_DESENCRYPTION_MODE_ECB;          
    memset(thisPtr->keySet,0,sizeof(thisPtr->keySet));    
    memset(thisPtr->key,0,sizeof(thisPtr->key));    
    thisPtr->encrypt = rvTrue; 
    return thisPtr;
}

/*$
{function scope="protected":
	{name: rvDesEncryptionDestruct }
	{class: RvDesEncryption }
	{include: rvdesencryption.h}
	{description:
		{p: This method destroys the object. }
	}
	{proto: void rvDesEncryptionDestruct(RvDesEncryption* thisPtr);}
	{params:
		{param: {n: thisPtr} {d:The RvDesEncryption object to destruct.}}
	}
}
$*/
void rvDesEncryptionDestruct(RvDesEncryption *thisPtr)
{
    /* Nothing to do */
}

/*$
{function scope="protected":
	{name: rvDesEncryptionInitializeECBMode }
	{class: RvDesEncryption }
	{include: rvdesencryption.h}
	{description:
		{p: Initializes to RvDesEncryption object for ECB mode encryption or
            decryption. }
	}
	{proto: void rvDesEncryptionInitializeECBMode(RvDesEncryption* thisPtr, RvUint8 direction, const RvUint8 key[7]);}
	{params:
		{param: {n: thisPtr}      {d:The RvDesEncryption object to initialize.}}
		{param: {n: direction}    {d:A flag to set the RvDesEncryption object to encrypt or decrypt. Use 
                                     RV_DESENCRYPTION_DIRECTION_ENCRYPT to encrypt, 
                                     RV_DESENCRYPTION_DIRECTION_DECRYPT to decrypt.}}
		{param: {n: key}          {d:The key to use.}}
	}
}
$*/
void rvDesEncryptionInitializeECBMode(RvDesEncryption *thisPtr, 
                                      RvUint8 direction,
                                      const RvUint8 key[7])
{
    thisPtr->mode = RV_DESENCRYPTION_MODE_ECB;
    thisPtr->encrypt = (direction == RV_DESENCRYPTION_DIRECTION_ENCRYPT);
    rvDesEncryptionExpandKey(key, thisPtr->key);
    rvDesEncryptionGenerateKeySet(thisPtr->key, thisPtr->keySet, thisPtr->encrypt);
    
    rvDesEncryptionReset(thisPtr);
}

/*$
{function scope="protected":
	{name: rvDesEncryptionInitializeCBCMode }
	{class: RvDesEncryption }
	{include: rvdesencryption.h}
	{description:
		{p: Initializes to RvDesEncryption object for CBC mode encryption or
            decryption. }
	}
	{proto: void rvDesEncryptionInitializeCBCMode(RvDesEncryption* thisPtr, RvUint8 direction, const RvUint8 key[7], const RvUint8 iv[8]);}
	{params:
		{param: {n: thisPtr}      {d:The RvDesEncryption object to initialize.}}
		{param: {n: direction}    {d:A flag to set the RvDesEncryption object to encrypt or decrypt. Use 
                                     RV_DESENCRYPTION_DIRECTION_ENCRYPT to encrypt, 
                                     RV_DESENCRYPTION_DIRECTION_DECRYPT to decrypt.}}
		{param: {n: key}          {d:The key to use.}}
		{param: {n: iv}           {d:The initialization vector to use.}}
	}
}
$*/
void rvDesEncryptionInitializeCBCMode(RvDesEncryption *thisPtr, 
                                      RvUint8 direction,
                                      const RvUint8 key[7],
                                      const RvUint8 iv[8])
{
    thisPtr->mode = RV_DESENCRYPTION_MODE_CBC;