From owner-freebsd-questions@FreeBSD.ORG Sun Aug 10 07:22:25 2003 Return-Path: Delivered-To: freebsd-questions@freebsd.org Received: from mx1.FreeBSD.org (mx1.freebsd.org [216.136.204.125]) by hub.freebsd.org (Postfix) with ESMTP id 71CA037B401 for ; Sun, 10 Aug 2003 07:22:25 -0700 (PDT) Received: from kira.skynet.be (kira.skynet.be [195.238.2.125]) by mx1.FreeBSD.org (Postfix) with ESMTP id 0CCC443F3F for ; Sun, 10 Aug 2003 07:22:24 -0700 (PDT) (envelope-from pascal.pype@skynet.be) Received: from skynet.be (32.26-201-80.adsl.skynet.be [80.201.26.32]) id h7AEMGSP020421 for ; Sun, 10 Aug 2003 16:22:16 +0200 (envelope-from ) Message-ID: <3F36570F.9080300@skynet.be> Date: Sun, 10 Aug 2003 16:30:39 +0200 From: Pascal Pype User-Agent: Mozilla/5.0 (X11; U; FreeBSD i386; en-US; rv:1.0.2) Gecko/20030323 X-Accept-Language: en-us, en MIME-Version: 1.0 To: questions@freebsd.org Content-Type: text/plain; charset=us-ascii; format=flowed Content-Transfer-Encoding: 7bit Subject: DES encryption. X-BeenThere: freebsd-questions@freebsd.org X-Mailman-Version: 2.1.1 Precedence: list List-Id: User questions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sun, 10 Aug 2003 14:22:25 -0000 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 #include #define _XOPEN_SOURCE #include #ifdef _LINUX #include #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.