int main() { unsigned long L = 1, R = 2; BLOWFISH_CTX ctx; Blowfish_Init (&ctx, (unsigned char*)"TESTKEY", 7); Blowfish_Encrypt(&ctx, &L, &R); printf("%08lX %08lX\n", L, R); if (L == 0xDF333FD2L && R == 0x30A71BB4L) printf("Test encryption OK.\n"); else printf("Test encryption failed.\n"); Blowfish_Decrypt(&ctx, &L, &R); if (L == 1 && R == 2) printf("Test decryption OK.\n"); else printf("Test decryption failed.\n"); return 0; }
static void BlowFishEncode(int len,BYTE *source,int len_key,BYTE* init) { BLOWFISH_CTX ctx; unsigned long lvalue,rvalue; int i; Blowfish_Init(&ctx,init,len_key); for (i=0; i < (len /8); i++) { lvalue = *source << 24 | *(source+1) << 16 | +*(source+2) << 8 | *(source+3); rvalue = *(source+4) << 24 | *(source+5) << 16 | +*(source+6) << 8 | *(source+7); Blowfish_Encrypt(&ctx,&lvalue,&rvalue); WORD_WRITE(source,lvalue >> 16); WORD_WRITE(source,lvalue & 0x0000ffff); WORD_WRITE(source,rvalue >> 16); WORD_WRITE(source,rvalue & 0x0000ffff); } }
/*--------------------------------------------------------------------------------*/ void ABlowfish::Encrypt(const uint8_t *src, uint8_t *dst, uint32_t& iv1, uint32_t& iv2) { BLOWFISH_CTX *ctx = (BLOWFISH_CTX *)GetContext(); uint32_t l, r; // copy bytes into 2 32-bit variables memcpy(&l, src, sizeof(l)); src += sizeof(l); memcpy(&r, src, sizeof(r)); // for little endian machines, swap bytes to make all data big-endian if (!MachineIsBigEndian()) { l = SwapBytes(l); r = SwapBytes(r); } // XOR in initialisation vectors (for CBC mode) l ^= iv1; r ^= iv2; // encrypt data Blowfish_Encrypt(ctx, &l, &r); // return new initialisation vectors (for CBC mode) iv1 = l; iv2 = r; // for little endian machines, swap bytes back to make all data little-endian if (!MachineIsBigEndian()) { l = SwapBytes(l); r = SwapBytes(r); } // copy bytes to destination memcpy(dst, &l, sizeof(l)); dst += sizeof(l); memcpy(dst, &r, sizeof(r)); l = r = 0; // clear local variables to prevent security leaks }
static forceinline void Encrypt(_BLOWFISH_CTX *ctx,unsigned long *IV_L,unsigned long *IV_R,unsigned long *left,unsigned long *right) { (void) IV_L; (void) IV_R; Blowfish_Encrypt(ctx,left,right); };
static void Blowfish_Init(_BLOWFISH_CTX *ctx, const unsigned char *key, unsigned int keyLen) { static const unsigned long dummy=0; unsigned int i; unsigned long *p,*s; ASSERT(keyLen>=4); ASSERT(keyLen<=56);//448 bit max! if (keyLen<4) { //SOS! key=(const unsigned char*)&dummy; keyLen=4; }; if (keyLen>56) { //SOS! keyLen=56; }; { p=ctx->P; const unsigned long *p0=ORIG_P; unsigned int j=0; if (ISLONGALIGN((size_t)key)&&ISLONGALIGN(keyLen)) { unsigned long *pulkey=(unsigned long*)key; unsigned long *pulmaxkey=(unsigned long*)(key+keyLen); for (i=0;i<(16+2);i++) { *p++ = *p0++ ^ SWAP(*pulkey++); if (pulkey>=pulmaxkey) pulkey=(unsigned long*)key; }; } else { unsigned long data=0; for (i=0;i<(16+2);i++) { unsigned int k; for (k=0;k<4;k++) { SETBYTE(data,3-k,key[j]);if (++j >= keyLen) j = 0; }; *p++ = *p0++ ^ data; }; }; }; memcpy(ctx->S,ORIG_S,sizeof(ORIG_S)); { unsigned long datal, datar; datal=0;datar=0; p=ctx->P; for (i=0;i<((16+2)/2);i++) { Blowfish_Encrypt(ctx, &datal, &datar); *p++ = datal; *p++ = datar; }; s=ctx->S; for (i=0;i<((4*256)/2);i++) { Blowfish_Encrypt(ctx, &datal, &datar); *s++ = datal; *s++ = datar; }; }; }
void CSocket::DoPrint(const wstring &wscTextIn) { wstring wscText(wscTextIn); for(uint i = 0; (i < wscText.length()); i++) { if(wscText[i] == '\n') { wscText.replace(i, 1, L"\r\n"); i++; } } int iSndBuf = 300000; // fix: set send-buffer to this size (bytes) int size = sizeof(int); setsockopt(this->s, SOL_SOCKET, SO_SNDBUF, (const char*)&iSndBuf, size); if(bEncrypted) { int iLen; char *data; const char* tempData; if(bUnicode) { uint iRem = (uint)(wscText.length() % 4); if(iRem) //Data to be encrypted is not a multiple of 8 bytes, add 0x00s to compensate { iRem = 4 - iRem; wscText.resize(wscText.length()+iRem, L'\x00'); } tempData = (const char*)wscText.data(); iLen = (uint)(wscText.length()*2); data = (char*)malloc(iLen); memcpy(data, tempData, iLen); } else { uint iRem = (uint)(wscText.length() % 8); if(iRem) { iRem = 8 - iRem; string scText = wstos(wscText); scText.resize(scText.length()+iRem,'\x00'); tempData = scText.data(); iLen = (int)scText.length(); data = (char*)malloc(iLen); memcpy(data, tempData, iLen); } else { string scText = wstos(wscText); tempData = scText.data(); iLen = (int)wscText.length(); data = (char*)malloc(iLen); memcpy(data, tempData, iLen); } } SwapBytes(data, iLen); if(Blowfish_Encrypt(bfc, data, iLen)) { SwapBytes(data, iLen); send(this->s, data, iLen, 0); free(data); } } else { if(bUnicode) send(this->s, (const char*)wscText.c_str(), (int)wscText.length()*2, 0); else send(this->s, wstos(wscText).c_str(), (int)wscText.length(), 0); } }
int encryption (char *key, unsigned char *plaintext_string, unsigned char *ciphertext_string, unsigned char *crypt64, int * ciphertext_len) { BLOWFISH_CTX ctx; int n; int keylen = strlen(key); int plaintext_len = strlen(plaintext_string); unsigned long message_left; unsigned long message_right; int block_len; char * ciphertext_string_ori = ciphertext_string; *ciphertext_len = 0; Blowfish_Init(&ctx, key, keylen); while (plaintext_len) { message_left = message_right = 0UL; /* crack the message string into a 64-bit block (ok, really two 32-bit blocks); pad with zeros if necessary */ for (block_len = 0; block_len < 4; block_len++) { message_left = message_left << 8; if (plaintext_len) { message_left += *plaintext_string++; plaintext_len--; } else message_left += 0; } for (block_len = 0; block_len < 4; block_len++) { message_right = message_right << 8; if (plaintext_len) { message_right += *plaintext_string++; plaintext_len--; } else message_right += 0; } /* encrypt and print the results */ Blowfish_Encrypt(&ctx, &message_left, &message_right); /* save the results for decryption below */ *ciphertext_string++ = (unsigned char)(message_left >> 24); *ciphertext_string++ = (unsigned char)(message_left >> 16); *ciphertext_string++ = (unsigned char)(message_left >> 8); *ciphertext_string++ = (unsigned char)message_left; *ciphertext_string++ = (unsigned char)(message_right >> 24); *ciphertext_string++ = (unsigned char)(message_right >> 16); *ciphertext_string++ = (unsigned char)(message_right >> 8); *ciphertext_string++ = (unsigned char)message_right; *ciphertext_len += 8; } encode_base64(*ciphertext_len, ciphertext_string_ori, crypt64 ); return 0; }