fc::blowfish Class Reference

#include <blowfish.hpp>

Public Types
enum	{ ECB =0 , CBC =1 , CFB =2 }

Public Member Functions
	blowfish ()
void	start (unsigned char *ucKey, uint64_t n, const sblock &roChain=sblock(0UL, 0UL))
void	reset_chain ()
void	encrypt (unsigned char *buf, uint64_t n, int iMode=CFB)
void	decrypt (unsigned char *buf, uint64_t n, int iMode=CFB)
void	encrypt (const unsigned char *in, unsigned char *out, uint64_t n, int iMode=CFB)
void	decrypt (const unsigned char *in, unsigned char *out, uint64_t n, int iMode=CFB)

Detailed Description

Definition at line 139 of file blowfish.hpp.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
ECB
CBC
CFB

Definition at line 142 of file blowfish.hpp.

{ ECB=0, CBC=1, CFB=2 };

Constructor & Destructor Documentation

blowfish()

fc::blowfish::blowfish

(

)

Definition at line 303 of file blowfish.cpp.

{}

Member Function Documentation

decrypt() [1/2]

void fc::blowfish::decrypt	(	const unsigned char *	in,
		unsigned char *	out,
		uint64_t	n,
		int	iMode = CFB )

Definition at line 581 of file blowfish.cpp.

{
    //Check the buffer's length - should be > 0 and multiple of 8
    if((n==0)||(n%8!=0))
        FC_THROW_EXCEPTION( exception, "invalid buffer length ${n}, not multiple of 8", ("n", n) ); 
    sblock work;
    if(iMode == CBC) //CBC mode, using the Chain
    {
        sblock crypt, chain(m_oChain);
        for(; n >= 8; n -= 8, in += 8)
        {
            BytesToBlock(in, work);
            crypt = work;
            decrypt(work);
            work ^= chain;
            chain = crypt;
            BlockToBytes(work, out+=8);
        }
    }
    else if(iMode == CFB) //CFB mode, using the Chain, not using decrypt()
    {
        sblock crypt, chain(m_oChain);
        for(; n >= 8; n -= 8, in += 8)
        {
            BytesToBlock(in, work);
            encrypt(chain);
            crypt = work;
            work ^= chain;
            chain = crypt;
            BlockToBytes(work, out+=8);
        }
    }
    else //ECB mode, not using the Chain
    {
        for(; n >= 8; n -= 8, in += 8)
        {
            BytesToBlock(in, work);
            decrypt(work);
            BlockToBytes(work, out+=8);
        }
    }
}

Here is the call graph for this function:

decrypt() [2/2]

void fc::blowfish::decrypt	(	unsigned char *	buf,
		uint64_t	n,
		int	iMode = CFB )

Definition at line 493 of file blowfish.cpp.

{
    //Check the buffer's length - should be > 0 and multiple of 8
    if((n==0)||(n%8!=0))
        FC_THROW_EXCEPTION( exception, "invalid buffer length ${n}, not multiple of 8", ("n", n) ); 
    sblock work;
    if(iMode == CBC) //CBC mode, using the Chain
    {
        sblock crypt, chain(m_oChain);
        for(; n >= 8; n -= 8)
        {
            BytesToBlock(buf, work);
            crypt = work;
            decrypt(work);
            work ^= chain;
            chain = crypt;
            BlockToBytes(work, buf+=8);
        }
    }
    else if(iMode == CFB) //CFB mode, using the Chain, not using decrypt()
    {
        sblock crypt, chain(m_oChain);
        for(; n >= 8; n -= 8)
        {
            BytesToBlock(buf, work);
            encrypt(chain);
            crypt = work;
            work ^= chain;
            chain = crypt;
            BlockToBytes(work, buf+=8);
        }
    }
    else //ECB mode, not using the Chain
    {
        for(; n >= 8; n -= 8)
        {
            BytesToBlock(buf, work);
            decrypt(work);
            BlockToBytes(work, buf+=8);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

encrypt() [1/2]

void fc::blowfish::encrypt	(	const unsigned char *	in,
		unsigned char *	out,
		uint64_t	n,
		int	iMode = CFB )

Definition at line 538 of file blowfish.cpp.

{
    //Check the buffer's length - should be > 0 and multiple of 8
    if((n==0)||(n%8!=0))
        FC_THROW_EXCEPTION( exception, "invalid buffer length ${n}, not multiple of 8", ("n", n) ); 
    sblock work;
    if(iMode == CBC) //CBC mode, using the Chain
    {
        sblock chain(m_oChain);
        for(; n >= 8; n -= 8, in += 8)
        {
            BytesToBlock(in, work);
            work ^= chain;
            encrypt(work);
            chain = work;
            BlockToBytes(work, out+=8);
        }
    }
    else if(iMode == CFB) //CFB mode, using the Chain
    {
        sblock chain(m_oChain);
        for(; n >= 8; n -= 8, in += 8)
        {
            encrypt(chain);
            BytesToBlock(in, work);
            work ^= chain;
            chain = work;
            BlockToBytes(work, out+=8);
        }
    }
    else //ECB mode, not using the Chain
    {
        for(; n >= 8; n -= 8, in += 8)
        {
            BytesToBlock(in, work);
            encrypt(work);
            BlockToBytes(work, out+=8);
        }
    }
}

Here is the call graph for this function:

encrypt() [2/2]

void fc::blowfish::encrypt	(	unsigned char *	buf,
		uint64_t	n,
		int	iMode = CFB )

Definition at line 450 of file blowfish.cpp.

{
    //Check the buffer's length - should be > 0 and multiple of 8
    if((n==0)||(n%8!=0))
        FC_THROW_EXCEPTION( exception, "invalid buffer length ${n}, not multiple of 8", ("n", n) ); 
    sblock work;
    if(iMode == CBC) //CBC mode, using the Chain
    {
        sblock chain(m_oChain);
        for(; n >= 8; n -= 8)
        {
            BytesToBlock(buf, work);
            work ^= chain;
            encrypt(work);
            chain = work;
            BlockToBytes(work, buf+=8);
        }
    }
    else if(iMode == CFB) //CFB mode, using the Chain
    {
        sblock chain(m_oChain);
        for(; n >= 8; n -= 8)
        {
            encrypt(chain);
            BytesToBlock(buf, work);
            work ^= chain;
            chain = work;
            BlockToBytes(work, buf+=8);
        }
    }
    else //ECB mode, not using the Chain
    {
        for(; n >= 8; n -= 8)
        {
            BytesToBlock(buf, work);
            encrypt(work);
            BlockToBytes(work, buf+=8);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

reset_chain()

void fc::blowfish::reset_chain ( )

inline

Definition at line 149 of file blowfish.hpp.

{ m_oChain = m_oChain0; }

start()

void fc::blowfish::start	(	unsigned char *	ucKey,
		uint64_t	n,
		const sblock &	roChain = sblock(0UL,0UL) )

Definition at line 306 of file blowfish.cpp.

{
    m_oChain0 = roChain;
    m_oChain  = roChain;
 
    if(keysize<1)
        FC_THROW_EXCEPTION( exception, "invalid key length" );
    //Check the Key - the key length should be between 1 and 56 bytes
    if(keysize>56)
        keysize = 56;
    unsigned char aucLocalKey[56];
    unsigned int i, j;
    memcpy(aucLocalKey, ucKey, static_cast<size_t>(keysize));
    //Reflexive Initialization of the Blowfish.
    //Generating the Subkeys from the Key flood P and S boxes with PI
    memcpy(m_auiP, scm_auiInitP, sizeof m_auiP);
    memcpy(m_auiS, scm_auiInitS, sizeof m_auiS);
    //Load P boxes with key bytes
    const unsigned char* p = aucLocalKey;
    unsigned int x=0;
    //Repeatedly cycle through the key bits until the entire P array has been XORed with key bits
    uint32_t iCount = 0;
    for(i=0; i<18; i++)
    {
        x=0;
        for(int n=4; n--; )
        {
            //int iVal = (int)(*p);
            x <<= 8;
            x |= *(p++);
            iCount++;
            if(iCount == keysize)
            {
                //All bytes used, so recycle bytes 
                iCount = 0;
                p = aucLocalKey;
            }
        }
        m_auiP[i] ^= x;
    }
    //Reflect P and S boxes through the evolving Blowfish
    sblock block(0UL,0UL); //all-zero block
    for(i=0; i<18; )
        encrypt(block), m_auiP[i++] = block.m_uil, m_auiP[i++] = block.m_uir;
    for(j=0; j<4; j++)
        for(int k=0; k<256; )
            encrypt(block), m_auiS[j][k++] = block.m_uil, m_auiS[j][k++] = block.m_uir;
}

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• libraries/fc/include/fc/crypto/blowfish.hpp
• libraries/fc/src/crypto/blowfish.cpp