int main( void )
{
int keysize;
unsigned long i, j, tsc;
unsigned char buf[BUFSIZE];
unsigned char tmp[32];
arc4_context arc4;
des3_context des3;
des_context des;
aes_context aes;
rsa_context rsa;
memset( buf, 0xAA, sizeof( buf ) );
printf( "\n" );
/*
* MD2 timing
*/
printf( " MD2 : " );
fflush( stdout );
set_alarm( 1 );
for( i = 1; ! alarmed; i++ )
md2_csum( buf, BUFSIZE, tmp );
tsc = hardclock();
for( j = 0; j < 32; j++ )
md2_csum( buf, BUFSIZE, tmp );
printf( "%9ld Kb/s, %9ld cycles/byte\n", i * BUFSIZE / 1024,
( hardclock() - tsc ) / ( j * BUFSIZE ) );
/*
* MD4 timing
*/
printf( " MD4 : " );
fflush( stdout );
set_alarm( 1 );
for( i = 1; ! alarmed; i++ )
md4_csum( buf, BUFSIZE, tmp );
tsc = hardclock();
for( j = 0; j < 1024; j++ )
md4_csum( buf, BUFSIZE, tmp );
printf( "%9ld Kb/s, %9ld cycles/byte\n", i * BUFSIZE / 1024,
( hardclock() - tsc ) / ( j * BUFSIZE ) );
/*
* MD5 timing
*/
printf( " MD5 : " );
fflush( stdout );
set_alarm( 1 );
for( i = 1; ! alarmed; i++ )
md5_csum( buf, BUFSIZE, tmp );
tsc = hardclock();
for( j = 0; j < 1024; j++ )
md5_csum( buf, BUFSIZE, tmp );
printf( "%9ld Kb/s, %9ld cycles/byte\n", i * BUFSIZE / 1024,
( hardclock() - tsc ) / ( j * BUFSIZE ) );
/*
* SHA-1 timing
*/
printf( " SHA-1 : " );
fflush( stdout );
set_alarm( 1 );
for( i = 1; ! alarmed; i++ )
sha1_csum( buf, BUFSIZE, tmp );
tsc = hardclock();
for( j = 0; j < 1024; j++ )
sha1_csum( buf, BUFSIZE, tmp );
printf( "%9ld Kb/s, %9ld cycles/byte\n", i * BUFSIZE / 1024,
( hardclock() - tsc ) / ( j * BUFSIZE ) );
/*
* SHA-256 timing
*/
printf( " SHA-256 : " );
fflush( stdout );
set_alarm( 1 );
for( i = 1; ! alarmed; i++ )
sha2_csum( buf, BUFSIZE, tmp );
tsc = hardclock();
for( j = 0; j < 1024; j++ )
sha2_csum( buf, BUFSIZE, tmp );
printf( "%9ld Kb/s, %9ld cycles/byte\n", i * BUFSIZE / 1024,
( hardclock() - tsc ) / ( j * BUFSIZE ) );
/*
* ARC4 timing
*/
printf( " ARC4 : " );
fflush( stdout );
arc4_setup( &arc4, tmp, 32 );
set_alarm( 1 );
for( i = 1; ! alarmed; i++ )
arc4_crypt( &arc4, buf, BUFSIZE );
tsc = hardclock();
for( j = 0; j < 1024; j++ )
arc4_crypt( &arc4, buf, BUFSIZE );
printf( "%9ld Kb/s, %9ld cycles/byte\n", i * BUFSIZE / 1024,
( hardclock() - tsc ) / ( j * BUFSIZE ) );
/*
* Triple-DES timing
*/
printf( " 3DES : " );
fflush( stdout );
des3_set_3keys( &des3, tmp );
set_alarm( 1 );
for( i = 1; ! alarmed; i++ )
des3_cbc_encrypt( &des3, tmp, buf, buf, BUFSIZE );
tsc = hardclock();
for( j = 0; j < 1024; j++ )
des3_cbc_encrypt( &des3, tmp, buf, buf, BUFSIZE );
printf( "%9ld Kb/s, %9ld cycles/byte\n", i * BUFSIZE / 1024,
( hardclock() - tsc ) / ( j * BUFSIZE ) );
/*
* DES timing
*/
printf( " DES : " );
fflush( stdout );
des_set_key( &des, tmp );
set_alarm( 1 );
for( i = 1; ! alarmed; i++ )
des_cbc_encrypt( &des, tmp, buf, buf, BUFSIZE );
tsc = hardclock();
for( j = 0; j < 1024; j++ )
des_cbc_encrypt( &des, tmp, buf, buf, BUFSIZE );
printf( "%9ld Kb/s, %9ld cycles/byte\n", i * BUFSIZE / 1024,
( hardclock() - tsc ) / ( j * BUFSIZE ) );
/*
* AES timings
*/
for( keysize = 128; keysize <= 256; keysize += 64 )
{
printf( " AES-%d : ", keysize );
fflush( stdout );
aes_set_key( &aes, tmp, keysize );
set_alarm( 1 );
for( i = 1; ! alarmed; i++ )
aes_cbc_encrypt( &aes, tmp, buf, buf, BUFSIZE );
tsc = hardclock();
for( j = 0; j < 1024; j++ )
aes_cbc_encrypt( &aes, tmp, buf, buf, BUFSIZE );
printf( "%9ld Kb/s, %9ld cycles/byte\n", i * BUFSIZE / 1024,
( hardclock() - tsc ) / ( j * BUFSIZE ) );
}
/*
* RSA-1024 timing
*/
printf( " RSA-1024 : " );
fflush( stdout );
rsa_gen_key( &rsa, 1024, 65537, myrand, NULL );
set_alarm( 4 );
for( i = 1; ! alarmed; i++ )
{
buf[0] = 0;
rsa_public( &rsa, buf, 128, buf, 128 );
}
printf( "%9ld public/s\n", i / 4 );
printf( " RSA-1024 : " );
fflush( stdout );
set_alarm( 4 );
for( i = 1; ! alarmed; i++ )
{
buf[0] = 0;
rsa_private( &rsa, buf, 128, buf, 128 );
}
printf( "%9ld private/s\n", i / 4 );
rsa_free( &rsa );
/*
* RSA-2048 timing
*/
printf( " RSA-2048 : " );
fflush( stdout );
rsa_gen_key( &rsa, 2048, 65537, myrand, NULL );
set_alarm( 4 );
for( i = 1; ! alarmed; i++ )
{
buf[0] = 0;
rsa_public( &rsa, buf, 256, buf, 256 );
}
printf( "%9ld public/s\n", i / 4 );
printf( " RSA-2048 : " );
fflush( stdout );
set_alarm( 4 );
for( i = 1; ! alarmed; i++ )
{
buf[0] = 0;
rsa_private( &rsa, buf, 256, buf, 256 );
}
printf( "%9ld private/s\n\n", i / 4 );
rsa_free( &rsa );
#ifdef WIN32
printf( " Press Enter to exit this program.\n" );
fflush( stdout ); getchar();
#endif
return( 0 );
}
EXPIMP_TEMPLATE INCHI_API int INCHI_DECL GetINCHIKeyFromINCHI(const char* szINCHISource,
const int xtra1,
const int xtra2,
char* szINCHIKey,
char* szXtra1,
char* szXtra2)
{
int ret = INCHIKEY_OK;
int ret1 = INCHIKEY_OK;
int cn;
size_t slen, i, j, jproto=0, ncp, pos_slash1=0;
char *str = NULL, *smajor = NULL, *sminor = NULL,
*sproto=NULL,
*stmp = NULL, tmp[MINOUTLENGTH];
unsigned char
digest_major[32], digest_minor[32];
char flagstd = 'S', /* standard key */
flagnonstd = 'N', /* non-standard key */
flagver = 'A', /* InChI v. 1 */
flagproto = 'N'; /* no [de]protonization , by default */
int nprotons;
/*
Protonization encoding:
N 0
O +1 P +2 Q +3 R +4 S +5 T +6 U +7 V +8 W +9 X +10 Y +11 Z +12
M -1 L-2 K -3 J -4 I -5 H -6 G -7 F -8 E -9 D -10 C -11 B -12
A < -12 or > +12
*/
static const char *pplus = "OPQRSTUVWXYZ";
static const char *pminus = "MLKJIHGFEDCB";
int bStdFormat = 0;
size_t bytelen = 32;
/* Check if input is a valid InChI string */
/* .. non-empty */
if (szINCHISource==NULL)
return INCHIKEY_EMPTY_INPUT;
slen = strlen(szINCHISource);
/* .. has valid prefix */
if (slen<LEN_INCHI_STRING_PREFIX+3)
return INCHIKEY_INVALID_INCHI_PREFIX;
if (memcmp(szINCHISource,INCHI_STRING_PREFIX,LEN_INCHI_STRING_PREFIX))
return INCHIKEY_INVALID_INCHI_PREFIX;
/* .. has InChI version 1 */
/* if (!isdigit(szINCHISource[LEN_INCHI_STRING_PREFIX]) ) */
if ( szINCHISource[LEN_INCHI_STRING_PREFIX] != '1' )
return INCHIKEY_INVALID_INCHI_PREFIX;
/* .. optionally has a 'standard' flag character */
pos_slash1 = LEN_INCHI_STRING_PREFIX+1;
if (szINCHISource[pos_slash1]=='S')
{
/* Standard InChI ==> standard InChIKey */
bStdFormat = 1;
pos_slash1++;
}
/* .. has trailing slash in the right place */
if (szINCHISource[pos_slash1]!='/')
return INCHIKEY_INVALID_INCHI_PREFIX;
/* .. the rest of source string contains at least one a..Z0.9 or slash */
/* TODO: improve/add full string check */
if (!isalnum(szINCHISource[pos_slash1+1] ) &&
( szINCHISource[pos_slash1+1]!='/' ) )
return INCHIKEY_INVALID_INCHI;
/*^^^ Ok. Will use a local copy of the source. */
extract_inchi_substring(&str, szINCHISource, slen);
if (NULL==str)
{
ret = INCHIKEY_NOT_ENOUGH_MEMORY;
goto fin;
}
slen = strlen(str);
/*^^^ Make buffers. */
smajor = (char*) inchi_calloc( slen+1, sizeof(char));
if (NULL==smajor)
{ ret = INCHIKEY_NOT_ENOUGH_MEMORY; goto fin; }
sminor = (char*) inchi_calloc( 2*slen + 2, sizeof(char)); /* we may double the length ... */
if (NULL==sminor)
{ ret = INCHIKEY_NOT_ENOUGH_MEMORY; goto fin; }
stmp = (char*) inchi_calloc( slen+1, sizeof(char));
if (NULL==stmp)
{ ret = INCHIKEY_NOT_ENOUGH_MEMORY; goto fin; }
sproto = (char*) inchi_calloc( slen+1, sizeof(char));
if (NULL==sproto)
{ ret = INCHIKEY_NOT_ENOUGH_MEMORY; goto fin; }
szINCHIKey[0] = '\0';
/*^^^ Extract the major block. */
smajor[0] = '\0';
for (j = pos_slash1 + 1; j < slen-1; j++)
{
if (str[j]=='/')
{
cn = str[j+1];
switch (cn)
{
/* anything allowed from a major part */
case 'c': case 'h': case 'q': continue;
/* "/p"; protons now go to to special string, not to minor hash */
case 'p': jproto = j;
continue;
/* "/f", "/r" : may not occur in stdInChI */
case 'f': case 'r': if ( bStdFormat )
{
ret = INCHIKEY_INVALID_STD_INCHI;
goto fin;
}
break;
/* anything allowed from a minor part */
default: break;
}
break;
}
}
j++;
if (j==slen)
j++;
else
j--;
ncp=0;
if (jproto)
ncp = jproto - pos_slash1 - 1;
else
ncp = j - pos_slash1 - 1;
/*^^^ Trim 'InChI=1[S]/' */
memcpy(smajor,str+pos_slash1+1, ncp*sizeof(str[0]));
smajor[ncp]='\0';
/* Treat protonization */
if (jproto)
{
/* 2009-01-07 fix bug/typo: assigned incorrect length to the protonation segment of
/* source string ( was sproto[ncp]='\0'; should be sproto[lenproto]='\0'; ) */
int lenproto = j - jproto;
if (lenproto<3)
{
/* empty "/p", should not occur */
ret = INCHIKEY_INVALID_INCHI;
goto fin;
}
memcpy(sproto,str+pos_slash1+ncp+1, lenproto*sizeof(str[0]));
sproto[lenproto]='\0';
nprotons = strtol( sproto+2, NULL, 10 );
if (nprotons > 0)
{
if (nprotons > 12) flagproto = 'A';
else flagproto = pplus[nprotons-1];
}
else if (nprotons < 0)
{
if (nprotons < -12) flagproto = 'A';
else flagproto = pminus[-nprotons-1];
}
else
{
/* should never occur */
ret = INCHIKEY_INVALID_STD_INCHI;
goto fin;
}
}
/*^^^ Extract the minor block. */
if (j != slen+1) /*^^^ check that something exists at right.*/
{
ncp = slen-j;
memcpy(sminor,str+j, (ncp)*sizeof(str[0]));
sminor[ncp]='\0';
}
else
sminor[0]='\0';
#if INCHIKEY_DEBUG
fprintf(stdout,"Source: {%-s}\n",str);
fprintf(stdout,"SMajor: {%-s}\n",smajor);
fprintf(stdout,"SMinor: {%-s}\n",sminor);
fprintf(stdout,"SProto: {%-s}\n",sproto);
#endif
/*^^^ Compute and compose the InChIKey string. */
/*^^^ Major hash sub-string. */
for( i = 0; i < 32; i++ )
digest_major[i] = 0;
sha2_csum( (unsigned char *) smajor, (int) strlen(smajor), digest_major );
/* !!! */
strcpy(tmp, base26_triplet_1(digest_major));
strcpy(tmp, base26_triplet_2(digest_major));
strcpy(tmp, base26_triplet_3(digest_major) );
strcpy(tmp, base26_triplet_4(digest_major) );
strcpy(tmp, base26_dublet_for_bits_56_to_64(digest_major));
sprintf(tmp,"%-.3s%-.3s%-.3s%-.3s%-.2s",
base26_triplet_1(digest_major), base26_triplet_2(digest_major),
base26_triplet_3(digest_major), base26_triplet_4(digest_major),
base26_dublet_for_bits_56_to_64(digest_major));
strcat(szINCHIKey, tmp);
#if (INCHIKEY_DEBUG>1)
fprint_digest(stderr, "Major hash, full SHA-256",digest_major);
#endif
/*^^^ Minor hash sub-string. */
for( i = 0; i < 32; i++ )
digest_minor[i] = 0;
slen = strlen(sminor);
if ((slen>0)&&(slen<255))
{
strcpy(stmp, sminor);
strcpy(sminor+slen,stmp);
}
sha2_csum( (unsigned char *) sminor, (int) strlen(sminor), digest_minor );
#if (INCHIKEY_DEBUG>1)
fprint_digest(stderr, "Minor hash, full SHA-256",digest_minor);
#endif
strcat(szINCHIKey, "-");
sprintf(tmp,"%-.3s%-.3s%-.2s",
base26_triplet_1(digest_minor),
base26_triplet_2(digest_minor),
base26_dublet_for_bits_28_to_36(digest_minor));
strcat(szINCHIKey, tmp);
/* Append a standard/non-standard flag */
slen = strlen(szINCHIKey);
if ( bStdFormat )
szINCHIKey[slen] = flagstd;
else
szINCHIKey[slen] = flagnonstd;
/*^^^ Append InChI v.1 flag */
szINCHIKey[slen+1] = flagver;
/*^^^ Append dash */
szINCHIKey[slen+2] = '-';
/*^^^ Append protonization flag */
szINCHIKey[slen+3] = flagproto;
szINCHIKey[slen+4] = '\0';
#if INCHIKEY_DEBUG
fprintf(stdout,"szINCHIKey: {%-s}\n",szINCHIKey);
#endif
/* Hash extensions */
if ( xtra1 && szXtra1 )
{
get_xtra_hash_major_hex(digest_major, szXtra1);
#if INCHIKEY_DEBUG
fprintf(stderr,"XHash1=%-s\n",szXtra1);
fprintf(stderr,"j=%-d\n",j);
#endif
}
if ( xtra2 && szXtra2 )
{
get_xtra_hash_minor_hex(digest_minor, szXtra2);
#if INCHIKEY_DEBUG
fprintf(stderr,"XHash2=%-s\n",szXtra2);
fprintf(stderr,"j=%-d\n",j);
#endif
}
fin:if (NULL!=str) inchi_free(str);
if (NULL!=smajor) inchi_free(smajor);
if (NULL!=sminor) inchi_free(sminor);
if (NULL!=stmp) inchi_free(stmp);
if (NULL!=sproto) inchi_free(sproto);
if ( (ret==INCHIKEY_OK) && (ret1!=INCHIKEY_OK) )
ret = ret1;
return ret;
}
