DES encryption.

Thu, 14 Aug 2003 12:30:32 -0700

Hello all,

There seems to be a problem when one wants to use
the DES encryption algorithm within the freeBSD
platform.

When one compiles this :

*/

#define _C_PLUS_PLUS

// General headers.

#include <stdlib.h>
#include <string.h>

#define _XOPEN_SOURCE
#include <unistd.h>
#ifdef _LINUX
#include <crypt.h>
#endif

// Software package specific headers.

#include "type.h"

#include "desEncDec.h"

#include "desEncDecP.h"

const U8 TDesEncryptorDecryptor::mNR_NIBBLES_PER_WORD = 4;

// Class constructor.

TDesEncryptorDecryptor::TDesEncryptorDecryptor()
  : mNR_BITS_PER_NIBBLE(4),
    mNR_BYTES_PER_DES_BLOCK(NR_BITS_PER_DES_BLOCK / 8),
    mNR_DWORDS_PER_DES_BLOCK(mNR_BYTES_PER_DES_BLOCK / 4),
    mNR_BITS_PER_DWORD(32),
    mBase16ToBase2Mask(0x8000),
    mByteToBase2Mask(0x80000000),
    mSpace(0x20)
{ // TDesEncryptorDecryptor::TDesEncryptorDecrypt


} // TDesEncryptorDecryptor::TDesEncryptorDecrypt

// Class method helpers.

VOID TDesEncryptorDecryptor::Base16ToBase2(U32 Word,
                                           U8 NrNibbles,
                                           PC8 pBase2)
{ // TDesEncryptorDecryptor::Base16ToBase2

if (NrNibbles < mNR_NIBBLES_PER_WORD)
mBase16ToBase2Mask = mBase16ToBase2Mask >> (NrNibbles * mNR_BITS_PER_NIBBLE);

  U8 j;
  for (j = 0;j < NrNibbles * mNR_BITS_PER_NIBBLE;j++) {

    if (Word & mBase16ToBase2Mask)
      pBase2[mBase2Pos++] = '\1';
    else
      pBase2[mBase2Pos++] = '\0';
    Word = Word << 1;

}

} // TDesEncryptorDecryptor::Base16ToBase2

VOID TDesEncryptorDecryptor::base16KeytoBase2Key(PC8 pKeyWord,
                                                 U8 NrNibbles)
{ // TDesEncryptorDecryptor::base16KeytoBase2Key

C8 pWord[mNR_NIBBLES_PER_WORD + 1];

  strncpy(pWord,pKeyWord,NrNibbles);
  pWord[NrNibbles] = 0x0;
  U32 Word = strtol(pWord,0,16);

Base16ToBase2(Word,NrNibbles,m_pBase2Key);

} // TDesEncryptorDecryptor::base16KeytoBase2Key

VOID TDesEncryptorDecryptor::Base16KeyToBase2Key(PC8 pKey)                             
         
{ // TDesEncryptorDecryptor::Base16KeyToBase2Key

  U8 NrNibblesPerKey = strlen(pKey);
  U8 NrWordsPerKey = NrNibblesPerKey / mNR_NIBBLES_PER_WORD;
  U8 NrResNibblesInKey = NrNibblesPerKey % mNR_NIBBLES_PER_WORD;

  mBase2Pos = 0;
  U8 i;
  for (i = 0;i < NrWordsPerKey;i++) {

    base16KeytoBase2Key(pKey,mNR_NIBBLES_PER_WORD);
    pKey += mNR_NIBBLES_PER_WORD;

}

  if (NrResNibblesInKey)
    base16KeytoBase2Key(pKey,NrResNibblesInKey);

  U8 NrBitsPerKey = NrNibblesPerKey * mNR_BITS_PER_NIBBLE;
  U8 NrResBitsPerKey = NR_BITS_PER_DES_KEY - NrBitsPerKey;

  memmove(m_pBase2Key + NrResBitsPerKey - 1,m_pBase2Key,NrBitsPerKey);
  memset(m_pBase2Key,0,NrResBitsPerKey);

} // TDesEncryptorDecryptor::Base16KeyToBase2Key

// Class method.

VOID TDesEncryptorDecryptor::SetKey(PC8 pKey)
{ // TDesEncryptorDecryptor::SetKey

Base16KeyToBase2Key(pKey);

setkey(m_pBase2Key);

} // TDesEncryptorDecryptor::SetKey

// Class method helpers.

VOID TDesEncryptorDecryptor::RecalibrateBuffer(PDesAlgorithmBuffer pDesAlgoBuf,
U8 & RecalibrateDelta)
{ // TDesEncryptorDecryptor::RecalibrateBuffer

  U32 BufLen = pDesAlgoBuf->Length;
  U8 LengthResidu = BufLen % mNR_BYTES_PER_DES_BLOCK;

if (LengthResidu) {

RecalibrateDelta = mNR_BYTES_PER_DES_BLOCK - LengthResidu;
U32 RecalibratedBufLen = BufLen + RecalibrateDelta;
pDesAlgoBuf->pBuffer = (PU8) realloc(pDesAlgoBuf->pBuffer,RecalibratedBufLen);
memset(pDesAlgoBuf->pBuffer + BufLen,mSpace,RecalibrateDelta);
pDesAlgoBuf->Length = RecalibratedBufLen;

  }
  else
    RecalibrateDelta = 0;

} // TDesEncryptorDecryptor::RecalibrateBuffer

VOID TDesEncryptorDecryptor::StripHeaderFromBuffer(PDesAlgorithmBuffer pDesAlgoBuf,
U8 & RecalibrateDelta)
{ // TDesEncryptorDecryptor::StripHeaderFromBuffer

  RecalibrateDelta = * pDesAlgoBuf->pBuffer;
  pDesAlgoBuf->Length -= sizeof(U8);
  pDesAlgoBuf->pBuffer += sizeof(U8);

} // TDesEncryptorDecryptor::StripHeaderFromBuffer

VOID TDesEncryptorDecryptor::ReorganizeBytes(U32 & dWord)
{ // TDesEncryptorDecryptor::ReorganizeBytes

  U8 p_dWord[mNR_BITS_PER_DWORD / 8];
  PU8 pByteInDWord = (PU8) (& dWord);

U8 NrBytesPerDWord = mNR_BITS_PER_DWORD / 8;

  U8 i;
  for (i = 0;i < NrBytesPerDWord;i++)
    p_dWord[NrBytesPerDWord - 1 - i] = *pByteInDWord++;

dWord = * ((PU32) p_dWord);

} // TDesEncryptorDecryptor::ReorganizeBytes

VOID TDesEncryptorDecryptor::ByteBlockToBase2Block(PU8 pBuffer)
{ // TDesEncryptorDecryptor::ByteBlockToBase2Block

mBase2Pos = 0;

  U8 i;
  for (i = 0;i < mNR_DWORDS_PER_DES_BLOCK;i++) {

U32 dWord = *((PU32) pBuffer);

ReorganizeBytes(dWord);

    U8 j;
    for (j = 0;j < mNR_BITS_PER_DWORD;j++) {

      if (dWord & mByteToBase2Mask)
        m_pBase2Block[mBase2Pos++] = '\1';
      else
        m_pBase2Block[mBase2Pos++] = '\0';

dWord = dWord << 1;

}

pBuffer += sizeof(U32);

}

} // TDesEncryptorDecryptor::ByteBlockToBase2Block

VOID TDesEncryptorDecryptor::ReorganizeBits()
{ // TDesEncryptorDecryptor::ReorganizeBits

C8 Tmp;

  U8 i;
  U8 NrBitsPerWord = mNR_BITS_PER_DWORD / 2;
  for (i = 0;i < NrBitsPerWord;i++) {

    Tmp = m_pBase2Block[i];
    m_pBase2Block[i] = m_pBase2Block[mNR_BITS_PER_DWORD - i - 1];
    m_pBase2Block[mNR_BITS_PER_DWORD - i - 1] = Tmp;

Tmp = m_pBase2Block[i + mNR_BITS_PER_DWORD];
m_pBase2Block[i + mNR_BITS_PER_DWORD] = m_pBase2Block[2 * mNR_BITS_PER_DWORD - i - 1];
m_pBase2Block[2 * mNR_BITS_PER_DWORD - i - 1] = Tmp;

}

} // TDesEncryptorDecryptor::ReorganizeBits

VOID TDesEncryptorDecryptor::Base2BlockToByteBlock(PU8 pBuffer)
{ // TDesEncryptorDecryptor::Base2BlockToByteBlock

mBase2Pos = 0;

ReorganizeBits();

  U8 i;
  for (i = 0;i < mNR_DWORDS_PER_DES_BLOCK;i++) {

    U32 dWord = 0;
    U32 Weight = 1;

    U8 j;
    for (j = 0;j < mNR_BITS_PER_DWORD;j++) {

      if (m_pBase2Block[mBase2Pos++] == '\1')
        dWord += Weight;
      Weight *= 2;

}

ReorganizeBytes(dWord);

memcpy(pBuffer,& dWord,sizeof(U32));

pBuffer += sizeof(U32);

}

} // TDesEncryptorDecryptor::Base2BlockToByteBlock

VOID TDesEncryptorDecryptor::AddHeaderToBuffer(PDesAlgorithmBuffer pDesAlgoBuf,
U8 RecalibrateDelta)
{ // TDesEncryptorDecryptor::AddHeaderToBuffer

pDesAlgoBuf->pBuffer = (PU8) realloc(pDesAlgoBuf->pBuffer,pDesAlgoBuf->Length + sizeof(U32) + sizeof(U8));
memmove(pDesAlgoBuf->pBuffer + sizeof(U32) + sizeof(U8),pDesAlgoBuf->pBuffer,pDesAlgoBuf->Length);
pDesAlgoBuf->Length += sizeof(U8);
memcpy(pDesAlgoBuf->pBuffer,& pDesAlgoBuf->Length,sizeof(U32));
memcpy(pDesAlgoBuf->pBuffer + sizeof(U32),& RecalibrateDelta,sizeof(U8));
pDesAlgoBuf->Length += sizeof(U32);

} // TDesEncryptorDecryptor::AddHeaderToBuffer

VOID TDesEncryptorDecryptor::IterateOverBuffer(PDesAlgorithmBuffer pDesAlgoBuf)
{ // TDesEncryptorDecryptor::IterateOverBuffer

U8 RecalibrateDelta;

  if (m_fDecr)
    StripHeaderFromBuffer(pDesAlgoBuf,RecalibrateDelta);
  else
    RecalibrateBuffer(pDesAlgoBuf,RecalibrateDelta);

  U32 i;
  U32 NrDesBlocks = pDesAlgoBuf->Length / mNR_BYTES_PER_DES_BLOCK;
  PU8 pBuf = pDesAlgoBuf->pBuffer;

for (i = 0;i < NrDesBlocks;i++) {

    ByteBlockToBase2Block(pBuf);
    encrypt(m_pBase2Block,m_fDecr);
    Base2BlockToByteBlock(pBuf);

pBuf += mNR_BYTES_PER_DES_BLOCK;

}

  if (m_fDecr)
    pDesAlgoBuf->Length -= RecalibrateDelta;
  else
    AddHeaderToBuffer(pDesAlgoBuf,RecalibrateDelta);

} // TDesEncryptorDecryptor::IterateOverBuffer

VOID TDesEncryptorDecryptor::FreeDesAlgorithmBuffer(PDesAlgorithmBuffer pDesAlgoBuf)
{ // TDesEncryptorDecryptor::FreeDesAlgorithmBuffer

  if (m_fDecr)
    free(pDesAlgoBuf->pBuffer - sizeof(U8));
  else
    free (pDesAlgoBuf->pBuffer);

} // TDesEncryptorDecryptor::FreeDesAlgorithmBuffer

// Class methods.

VOID TDesEncryptorDecryptor::Encrypt(PDesAlgorithmBuffer pDesAlgoBuf)
{ // TDesEncryptorDecryptor::Encrypt

  m_fDecr = 0;
  IterateOverBuffer(pDesAlgoBuf);

} // TDesEncryptorDecryptor::Encrypt

VOID TDesEncryptorDecryptor::Decrypt(PDesAlgorithmBuffer pDesAlgoBuf)
{ // TDesEncryptorDecryptor::Decrypt

  m_fDecr = 1;
  IterateOverBuffer(pDesAlgoBuf);

} // TDesEncryptorDecryptor::Decrypt

// Interface commands.

HDesEncryptorDecryptor OpenDesEncryptorDecryptor()
{ // OpenDesEncryptorDecryptor

PDesEncryptorDecryptor pDesEncDec = new TDesEncryptorDecryptor();

return (HDesEncryptorDecryptor) pDesEncDec;

} // OpenDesEncryptorDecryptor

VOID CloseDesEncryptorDecryptor(HDesEncryptorDecryptor hDesEncDec)
{ // CloseDesEncryptorDecryptor

PDesEncryptorDecryptor pDesEncDec = (PDesEncryptorDecryptor) hDesEncDec;

delete pDesEncDec;

} // CloseDesEncryptorDecrptor

VOID SetKey(HDesEncryptorDecryptor hDesEncDec,
            PC8 pKey)
{ // SetKey

PDesEncryptorDecryptor pDesEncDec = (PDesEncryptorDecryptor) hDesEncDec;

pDesEncDec->SetKey(pKey);

} // SetKey

VOID Encrypt(HDesEncryptorDecryptor hDesEncDec,
             PDesAlgorithmBuffer pDesAlgoBuf)
{ // Encrypt

PDesEncryptorDecryptor pDesEncDec = (PDesEncryptorDecryptor) hDesEncDec;

pDesEncDec->Encrypt(pDesAlgoBuf);

} // Encrypt

VOID Decrypt(HDesEncryptorDecryptor hDesEncDec,
             PDesAlgorithmBuffer pDesAlgoBuf)
{ // Decrypt

PDesEncryptorDecryptor pDesEncDec = (PDesEncryptorDecryptor) hDesEncDec;

pDesEncDec->Decrypt(pDesAlgoBuf);

} // Decrypt

VOID FreeDesAlgorithmBuffer(HDesEncryptorDecryptor hDesEncDec,
                            PDesAlgorithmBuffer pDesAlgoBuf)
{ // FreeDesAlgorithmBuffer

PDesEncryptorDecryptor pDesEncDec = (PDesEncryptorDecryptor) hDesEncDec;

pDesEncDec->FreeDesAlgorithmBuffer(pDesAlgoBuf);

} // FreeDesAlgorithmBuffer

one gets the following warning message at runtime:


"WARNING! encrypt(3) not present in the system".

I use freeBSD release 4.8.

My kind regards , Pype Pascal.

_______________________________________________
[EMAIL PROTECTED] mailing list
http://lists.freebsd.org/mailman/listinfo/freebsd-questions
To unsubscribe, send any mail to "[EMAIL PROTECTED]"

Reply via email to