Пример #1
0
static void blowfish_decrypt(u_char *src, u_char *dst, int len, void *state)
{
   struct blowfish_state *dstate;

   dstate = (struct blowfish_state *)state;
   swap_bytes(src, dst, len);
   BF_cbc_encrypt((void *)dst, dst, len, &dstate->key, dstate->iv, BF_DECRYPT);
   swap_bytes(dst, dst, len);
}
Пример #2
0
void
blowfish_encrypt(u_char *src, u_char *dst, int len, void *state)
{
	struct blowfish_state *estate;

	estate = (struct blowfish_state *)state;
	swap_bytes(src, dst, len);
	BF_cbc_encrypt((void *)dst, dst, len, &estate->key, estate->iv,
		       BF_ENCRYPT);
	swap_bytes(dst, dst, len);
}
Пример #3
0
std::string
HashUtils::blowfish(const char *data, unsigned long data_len,
                    const char *key, unsigned long key_len, const char *ivec) {

    unsigned char ivec_buffer[8];
    memset(ivec_buffer, 0, 8);
    memcpy(ivec_buffer, ivec, std::min(strlen(ivec), (size_t)8));

    BF_KEY bfkey;

    BF_set_key(&bfkey, key_len, (unsigned char *)key);

    size_t padded_datasize = (data_len % 8) ? 8*(data_len/8 + 1) : data_len;

    unsigned char buffer[padded_datasize];

    if (padded_datasize > data_len) {
        ByteArrayType input;
        input.reserve(padded_datasize);
        input.insert(input.end(), data, data + data_len);
        input.insert(input.end(), padded_datasize - data_len, '\0');
        BF_cbc_encrypt((unsigned char *)&*input.begin(),
            (unsigned char *)buffer,
            padded_datasize,
            &bfkey,
            (unsigned char *)ivec_buffer,
            BF_ENCRYPT);
    }
    else {
        BF_cbc_encrypt((unsigned char *)data,
            (unsigned char *)buffer,
            padded_datasize,
            &bfkey,
            (unsigned char *)ivec_buffer,
            BF_ENCRYPT);
    }

    return std::string(buffer, buffer + padded_datasize);
}
Пример #4
0
int OS_BF_Str(char *input, char *output, char *charkey, 
                long size, short int action)
{
    BF_KEY key;
    static unsigned char cbc_iv [8]={0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10};
    unsigned char iv[8];

    memcpy(iv,cbc_iv,sizeof(iv));

    BF_set_key(&key, strlen(charkey), (uchar *)charkey);

    BF_cbc_encrypt((uchar *)input, (uchar *)output, size,
            &key, iv, action);

    return(1);
}
Пример #5
0
static void blowfish_decrypt(struct crypto_struct *cipher, void *in,
    void *out, unsigned long len, void *IV) {
  BF_cbc_encrypt(in, out, len, cipher->key, IV, BF_DECRYPT);
}
Пример #6
0
static int test(void)
	{
	unsigned char cbc_in[40],cbc_out[40],iv[8];
	int i,n,err=0;
	BF_KEY key;
	BF_LONG data[2]; 
	unsigned char out[8]; 
	BF_LONG len;

#ifdef CHARSET_EBCDIC
	ebcdic2ascii(cbc_data, cbc_data, TINYCLR_SSL_STRLEN(cbc_data));
#endif

	TINYCLR_SSL_PRINTF("testing blowfish in raw ecb mode\n");
	for (n=0; n<2; n++)
		{
#ifdef CHARSET_EBCDIC
		ebcdic2ascii(bf_key[n], bf_key[n], TINYCLR_SSL_STRLEN(bf_key[n]));
#endif
		BF_set_key(&key,TINYCLR_SSL_STRLEN(bf_key[n]),(unsigned char *)bf_key[n]);

		data[0]=bf_plain[n][0];
		data[1]=bf_plain[n][1];
		BF_encrypt(data,&key);
		if (TINYCLR_SSL_MEMCMP(&(bf_cipher[n][0]),&(data[0]),8) != 0)
			{
			TINYCLR_SSL_PRINTF("BF_encrypt error encrypting\n");
			TINYCLR_SSL_PRINTF("got     :");
			for (i=0; i<2; i++)
				TINYCLR_SSL_PRINTF("%08lX ",(unsigned long)data[i]);
			TINYCLR_SSL_PRINTF("\n");
			TINYCLR_SSL_PRINTF("expected:");
			for (i=0; i<2; i++)
				TINYCLR_SSL_PRINTF("%08lX ",(unsigned long)bf_cipher[n][i]);
			err=1;
			TINYCLR_SSL_PRINTF("\n");
			}

		BF_decrypt(&(data[0]),&key);
		if (TINYCLR_SSL_MEMCMP(&(bf_plain[n][0]),&(data[0]),8) != 0)
			{
			TINYCLR_SSL_PRINTF("BF_encrypt error decrypting\n");
			TINYCLR_SSL_PRINTF("got     :");
			for (i=0; i<2; i++)
				TINYCLR_SSL_PRINTF("%08lX ",(unsigned long)data[i]);
			TINYCLR_SSL_PRINTF("\n");
			TINYCLR_SSL_PRINTF("expected:");
			for (i=0; i<2; i++)
				TINYCLR_SSL_PRINTF("%08lX ",(unsigned long)bf_plain[n][i]);
			TINYCLR_SSL_PRINTF("\n");
			err=1;
			}
		}

	TINYCLR_SSL_PRINTF("testing blowfish in ecb mode\n");

	for (n=0; n<NUM_TESTS; n++)
		{
		BF_set_key(&key,8,ecb_data[n]);

		BF_ecb_encrypt(&(plain_data[n][0]),out,&key,BF_ENCRYPT);
		if (TINYCLR_SSL_MEMCMP(&(cipher_data[n][0]),out,8) != 0)
			{
			TINYCLR_SSL_PRINTF("BF_ecb_encrypt blowfish error encrypting\n");
			TINYCLR_SSL_PRINTF("got     :");
			for (i=0; i<8; i++)
				TINYCLR_SSL_PRINTF("%02X ",out[i]);
			TINYCLR_SSL_PRINTF("\n");
			TINYCLR_SSL_PRINTF("expected:");
			for (i=0; i<8; i++)
				TINYCLR_SSL_PRINTF("%02X ",cipher_data[n][i]);
			err=1;
			TINYCLR_SSL_PRINTF("\n");
			}

		BF_ecb_encrypt(out,out,&key,BF_DECRYPT);
		if (TINYCLR_SSL_MEMCMP(&(plain_data[n][0]),out,8) != 0)
			{
			TINYCLR_SSL_PRINTF("BF_ecb_encrypt error decrypting\n");
			TINYCLR_SSL_PRINTF("got     :");
			for (i=0; i<8; i++)
				TINYCLR_SSL_PRINTF("%02X ",out[i]);
			TINYCLR_SSL_PRINTF("\n");
			TINYCLR_SSL_PRINTF("expected:");
			for (i=0; i<8; i++)
				TINYCLR_SSL_PRINTF("%02X ",plain_data[n][i]);
			TINYCLR_SSL_PRINTF("\n");
			err=1;
			}
		}

	TINYCLR_SSL_PRINTF("testing blowfish set_key\n");
	for (n=1; n<KEY_TEST_NUM; n++)
		{
		BF_set_key(&key,n,key_test);
		BF_ecb_encrypt(key_data,out,&key,BF_ENCRYPT);
		/* mips-sgi-irix6.5-gcc  vv  -mabi=64 bug workaround */
		if (TINYCLR_SSL_MEMCMP(out,&(key_out[i=n-1][0]),8) != 0)
			{
			TINYCLR_SSL_PRINTF("blowfish setkey error\n");
			err=1;
			}
		}

	TINYCLR_SSL_PRINTF("testing blowfish in cbc mode\n");
	len=TINYCLR_SSL_STRLEN(cbc_data)+1;

	BF_set_key(&key,16,cbc_key);
	TINYCLR_SSL_MEMSET(cbc_in,0,sizeof cbc_in);
	TINYCLR_SSL_MEMSET(cbc_out,0,sizeof cbc_out);
	TINYCLR_SSL_MEMCPY(iv,cbc_iv,sizeof iv);
	BF_cbc_encrypt((unsigned char *)cbc_data,cbc_out,len,
		&key,iv,BF_ENCRYPT);
	if (TINYCLR_SSL_MEMCMP(cbc_out,cbc_ok,32) != 0)
		{
		err=1;
		TINYCLR_SSL_PRINTF("BF_cbc_encrypt encrypt error\n");
		for (i=0; i<32; i++) TINYCLR_SSL_PRINTF("0x%02X,",cbc_out[i]);
		}
	TINYCLR_SSL_MEMCPY(iv,cbc_iv,8);
	BF_cbc_encrypt(cbc_out,cbc_in,len,
		&key,iv,BF_DECRYPT);
	if (TINYCLR_SSL_MEMCMP(cbc_in,cbc_data,TINYCLR_SSL_STRLEN(cbc_data)+1) != 0)
		{
		TINYCLR_SSL_PRINTF("BF_cbc_encrypt decrypt error\n");
		err=1;
		}

	TINYCLR_SSL_PRINTF("testing blowfish in cfb64 mode\n");

	BF_set_key(&key,16,cbc_key);
	TINYCLR_SSL_MEMSET(cbc_in,0,40);
	TINYCLR_SSL_MEMSET(cbc_out,0,40);
	TINYCLR_SSL_MEMCPY(iv,cbc_iv,8);
	n=0;
	BF_cfb64_encrypt((unsigned char *)cbc_data,cbc_out,(long)13,
		&key,iv,&n,BF_ENCRYPT);
	BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]),&(cbc_out[13]),len-13,
		&key,iv,&n,BF_ENCRYPT);
	if (TINYCLR_SSL_MEMCMP(cbc_out,cfb64_ok,(int)len) != 0)
		{
		err=1;
		TINYCLR_SSL_PRINTF("BF_cfb64_encrypt encrypt error\n");
		for (i=0; i<(int)len; i++) TINYCLR_SSL_PRINTF("0x%02X,",cbc_out[i]);
		}
	n=0;
	TINYCLR_SSL_MEMCPY(iv,cbc_iv,8);
	BF_cfb64_encrypt(cbc_out,cbc_in,17,
		&key,iv,&n,BF_DECRYPT);
	BF_cfb64_encrypt(&(cbc_out[17]),&(cbc_in[17]),len-17,
		&key,iv,&n,BF_DECRYPT);
	if (TINYCLR_SSL_MEMCMP(cbc_in,cbc_data,(int)len) != 0)
		{
		TINYCLR_SSL_PRINTF("BF_cfb64_encrypt decrypt error\n");
		err=1;
		}

	TINYCLR_SSL_PRINTF("testing blowfish in ofb64\n");

	BF_set_key(&key,16,cbc_key);
	TINYCLR_SSL_MEMSET(cbc_in,0,40);
	TINYCLR_SSL_MEMSET(cbc_out,0,40);
	TINYCLR_SSL_MEMCPY(iv,cbc_iv,8);
	n=0;
	BF_ofb64_encrypt((unsigned char *)cbc_data,cbc_out,(long)13,&key,iv,&n);
	BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]),
		&(cbc_out[13]),len-13,&key,iv,&n);
	if (TINYCLR_SSL_MEMCMP(cbc_out,ofb64_ok,(int)len) != 0)
		{
		err=1;
		TINYCLR_SSL_PRINTF("BF_ofb64_encrypt encrypt error\n");
		for (i=0; i<(int)len; i++) TINYCLR_SSL_PRINTF("0x%02X,",cbc_out[i]);
		}
	n=0;
	TINYCLR_SSL_MEMCPY(iv,cbc_iv,8);
	BF_ofb64_encrypt(cbc_out,cbc_in,17,&key,iv,&n);
	BF_ofb64_encrypt(&(cbc_out[17]),&(cbc_in[17]),len-17,&key,iv,&n);
	if (TINYCLR_SSL_MEMCMP(cbc_in,cbc_data,(int)len) != 0)
		{
		TINYCLR_SSL_PRINTF("BF_ofb64_encrypt decrypt error\n");
		err=1;
		}

	return(err);
	}
Пример #7
0
static void blowfish_encrypt(struct ssh_cipher_struct *cipher, void *in,
    void *out, unsigned long len) {
  BF_cbc_encrypt(in, out, len, cipher->key, cipher->IV, BF_ENCRYPT);
}
Пример #8
0
int main(int argc, char **argv)
{
    long count;
    static unsigned char buf[BUFSIZE];
    static unsigned char key[] = {
        0x12,0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0,
        0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10,
    };
    BF_KEY sch;
    double a,b,c,d;
#ifndef SIGALRM
    long ca,cb,cc;
#endif

#ifndef TIMES
    printf("To get the most accurate results, try to run this\n");
    printf("program when this computer is idle.\n");
#endif

#ifndef SIGALRM
    printf("First we calculate the approximate speed ...\n");
    BF_set_key(&sch,16,key);
    count=10;
    do	{
        long i;
        BF_LONG data[2];

        count*=2;
        Time_F(START);
        for (i=count; i; i--)
            BF_encrypt(data,&sch);
        d=Time_F(STOP);
    } while (d < 3.0);
    ca=count/512;
    cb=count;
    cc=count*8/BUFSIZE+1;
    printf("Doing BF_set_key %ld times\n",ca);
#define COND(d)	(count != (d))
#define COUNT(d) (d)
#else
#define COND(c)	(run)
#define COUNT(d) (count)
    signal(SIGALRM,sig_done);
    printf("Doing BF_set_key for 10 seconds\n");
    alarm(10);
#endif

    Time_F(START);
    for (count=0,run=1; COND(ca); count+=4)
    {
        BF_set_key(&sch,16,key);
        BF_set_key(&sch,16,key);
        BF_set_key(&sch,16,key);
        BF_set_key(&sch,16,key);
    }
    d=Time_F(STOP);
    printf("%ld BF_set_key's in %.2f seconds\n",count,d);
    a=((double)COUNT(ca))/d;

#ifdef SIGALRM
    printf("Doing BF_encrypt's for 10 seconds\n");
    alarm(10);
#else
    printf("Doing BF_encrypt %ld times\n",cb);
#endif
    Time_F(START);
    for (count=0,run=1; COND(cb); count+=4)
    {
        BF_LONG data[2];

        BF_encrypt(data,&sch);
        BF_encrypt(data,&sch);
        BF_encrypt(data,&sch);
        BF_encrypt(data,&sch);
    }
    d=Time_F(STOP);
    printf("%ld BF_encrypt's in %.2f second\n",count,d);
    b=((double)COUNT(cb)*8)/d;

#ifdef SIGALRM
    printf("Doing BF_cbc_encrypt on %ld byte blocks for 10 seconds\n",
           BUFSIZE);
    alarm(10);
#else
    printf("Doing BF_cbc_encrypt %ld times on %ld byte blocks\n",cc,
           BUFSIZE);
#endif
    Time_F(START);
    for (count=0,run=1; COND(cc); count++)
        BF_cbc_encrypt(buf,buf,BUFSIZE,&sch,
                       &(key[0]),BF_ENCRYPT);
    d=Time_F(STOP);
    printf("%ld BF_cbc_encrypt's of %ld byte blocks in %.2f second\n",
           count,BUFSIZE,d);
    c=((double)COUNT(cc)*BUFSIZE)/d;

    printf("Blowfish set_key       per sec = %12.3f (%9.3fuS)\n",a,1.0e6/a);
    printf("Blowfish raw ecb bytes per sec = %12.3f (%9.3fuS)\n",b,8.0e6/b);
    printf("Blowfish cbc     bytes per sec = %12.3f (%9.3fuS)\n",c,8.0e6/c);
    exit(0);
#if defined(LINT) || defined(OPENSSL_SYS_MSDOS)
    return(0);
#endif
}
Пример #9
0
static int test(void)
	{
	unsigned char cbc_in[40],cbc_out[40],iv[8];
	int i,n,err=0;
	BF_KEY key;
	BF_LONG data[2]; 
	unsigned char out[8]; 
	BF_LONG len;

	printf("testing blowfish in raw ecb mode\n");
	for (n=0; n<2; n++)
		{
		BF_set_key(&key,strlen(bf_key[n]),(unsigned char *)bf_key[n]);

		data[0]=bf_plain[n][0];
		data[1]=bf_plain[n][1];
		BF_encrypt(data,&key);
		if (memcmp(&(bf_cipher[n][0]),&(data[0]), sizeof data) != 0)
			{
			printf("BF_encrypt error encrypting\n");
			printf("got     :");
			for (i=0; i<2; i++)
				printf("%08lX ",(unsigned long)data[i]);
			printf("\n");
			printf("expected:");
			for (i=0; i<2; i++)
				printf("%08lX ",(unsigned long)bf_cipher[n][i]);
			err=1;
			printf("\n");
			}

		BF_decrypt(&(data[0]),&key);
		if (memcmp(&(bf_plain[n][0]),&(data[0]),8) != 0)
			{
			printf("BF_encrypt error decrypting\n");
			printf("got     :");
			for (i=0; i<2; i++)
				printf("%08lX ",(unsigned long)data[i]);
			printf("\n");
			printf("expected:");
			for (i=0; i<2; i++)
				printf("%08lX ",(unsigned long)bf_plain[n][i]);
			printf("\n");
			err=1;
			}
		}

	printf("testing blowfish in ecb mode\n");

	for (n=0; n<NUM_TESTS; n++)
		{
		BF_set_key(&key,8,ecb_data[n]);

		BF_ecb_encrypt(&(plain_data[n][0]),out,&key,BF_ENCRYPT);
		if (memcmp(&(cipher_data[n][0]),out,8) != 0)
			{
			printf("BF_ecb_encrypt blowfish error encrypting\n");
			printf("got     :");
			for (i=0; i<8; i++)
				printf("%02X ",out[i]);
			printf("\n");
			printf("expected:");
			for (i=0; i<8; i++)
				printf("%02X ",cipher_data[n][i]);
			err=1;
			printf("\n");
			}

		BF_ecb_encrypt(out,out,&key,BF_DECRYPT);
		if (memcmp(&(plain_data[n][0]),out,8) != 0)
			{
			printf("BF_ecb_encrypt error decrypting\n");
			printf("got     :");
			for (i=0; i<8; i++)
				printf("%02X ",out[i]);
			printf("\n");
			printf("expected:");
			for (i=0; i<8; i++)
				printf("%02X ",plain_data[n][i]);
			printf("\n");
			err=1;
			}
		}

	printf("testing blowfish set_key\n");
	for (n=1; n<KEY_TEST_NUM; n++)
		{
		BF_set_key(&key,n,key_test);
		BF_ecb_encrypt(key_data,out,&key,BF_ENCRYPT);
		if (memcmp(out,&(key_out[n-1][0]),8) != 0)
			{
			printf("blowfish setkey error\n");
			err=1;
			}
		}

	printf("testing blowfish in cbc mode\n");
	len=strlen(cbc_data)+1;

	BF_set_key(&key,16,cbc_key);
	memset(cbc_in,0,sizeof cbc_in);
	memset(cbc_out,0,sizeof cbc_out);
	memcpy(iv,cbc_iv,sizeof iv);
	BF_cbc_encrypt((unsigned char *)cbc_data,cbc_out,len,
		&key,iv,BF_ENCRYPT);
	if (memcmp(cbc_out,cbc_ok,32) != 0)
		{
		err=1;
		printf("BF_cbc_encrypt encrypt error\n");
		for (i=0; i<32; i++) printf("0x%02X,",cbc_out[i]);
		}
	memcpy(iv,cbc_iv,8);
	BF_cbc_encrypt(cbc_out,cbc_in,len,
		&key,iv,BF_DECRYPT);
	if (memcmp(cbc_in,cbc_data,strlen(cbc_data)+1) != 0)
		{
		printf("BF_cbc_encrypt decrypt error\n");
		err=1;
		}

	printf("testing blowfish in cfb64 mode\n");

	BF_set_key(&key,16,cbc_key);
	memset(cbc_in,0,40);
	memset(cbc_out,0,40);
	memcpy(iv,cbc_iv,8);
	n=0;
	BF_cfb64_encrypt((unsigned char *)cbc_data,cbc_out,(long)13,
		&key,iv,&n,BF_ENCRYPT);
	BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]),&(cbc_out[13]),len-13,
		&key,iv,&n,BF_ENCRYPT);
	if (memcmp(cbc_out,cfb64_ok,(int)len) != 0)
		{
		err=1;
		printf("BF_cfb64_encrypt encrypt error\n");
		for (i=0; i<(int)len; i++) printf("0x%02X,",cbc_out[i]);
		}
	n=0;
	memcpy(iv,cbc_iv,8);
	BF_cfb64_encrypt(cbc_out,cbc_in,17,
		&key,iv,&n,BF_DECRYPT);
	BF_cfb64_encrypt(&(cbc_out[17]),&(cbc_in[17]),len-17,
		&key,iv,&n,BF_DECRYPT);
	if (memcmp(cbc_in,cbc_data,(int)len) != 0)
		{
		printf("BF_cfb64_encrypt decrypt error\n");
		err=1;
		}

	printf("testing blowfish in ofb64\n");

	BF_set_key(&key,16,cbc_key);
	memset(cbc_in,0,40);
	memset(cbc_out,0,40);
	memcpy(iv,cbc_iv,8);
	n=0;
	BF_ofb64_encrypt((unsigned char *)cbc_data,cbc_out,(long)13,&key,iv,&n);
	BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]),
		&(cbc_out[13]),len-13,&key,iv,&n);
	if (memcmp(cbc_out,ofb64_ok,(int)len) != 0)
		{
		err=1;
		printf("BF_ofb64_encrypt encrypt error\n");
		for (i=0; i<(int)len; i++) printf("0x%02X,",cbc_out[i]);
		}
	n=0;
	memcpy(iv,cbc_iv,8);
	BF_ofb64_encrypt(cbc_out,cbc_in,17,&key,iv,&n);
	BF_ofb64_encrypt(&(cbc_out[17]),&(cbc_in[17]),len-17,&key,iv,&n);
	if (memcmp(cbc_in,cbc_data,(int)len) != 0)
		{
		printf("BF_ofb64_encrypt decrypt error\n");
		err=1;
		}

	return(err);
	}