int main( int argc, char *argv[] )
{
char c;
unsigned char val;
char buf[9];
int x;
if( argc<2 )
{
printf(" example usage: parcon 0l 1l 2h 4h 7l\n");
return 2;
}
if( ioperm(BASE,1,1) )
{
printf("Couldn't get port %x\n",BASE);
return 1;
}
val = inb(BASE);
printf("old = %s\n",binprint(val,buf));
for( x=1; x<argc; x++ )
if( argv[x][1]!='h' )
val &= ~(1<<(argv[x][0]-'1'));
else
val |= 1<<(argv[x][0]-'1');
printf("new = %s\n",binprint(val,buf));
outb(val,BASE);
return 0;
}
void
doit (void)
{
char *out;
size_t i;
for (i = 0; i < sizeof (nfkc) / sizeof (nfkc[0]); i++)
{
if (debug)
printf ("NFKC entry %ld\n", i);
out = stringprep_utf8_nfkc_normalize (nfkc[i].in,
(ssize_t) strlen (nfkc[i].in));
if (out == NULL)
{
fail ("NFKC entry %ld failed fatally\n", i);
continue;
}
if (debug)
{
uint32_t *t;
size_t len;
printf ("in:\n");
escapeprint (nfkc[i].in, strlen (nfkc[i].in));
hexprint (nfkc[i].in, strlen (nfkc[i].in));
binprint (nfkc[i].in, strlen (nfkc[i].in));
printf ("out:\n");
escapeprint (out, strlen (out));
hexprint (out, strlen (out));
binprint (out, strlen (out));
t = stringprep_utf8_to_ucs4 (out, -1, &len);
if (t)
{
ucs4print (t, len);
free (t);
}
printf ("expected out:\n");
escapeprint (nfkc[i].out, strlen (nfkc[i].out));
hexprint (nfkc[i].out, strlen (nfkc[i].out));
binprint (nfkc[i].out, strlen (nfkc[i].out));
}
if (strlen (nfkc[i].out) != strlen (out) ||
memcmp (nfkc[i].out, out, strlen (out)) != 0)
{
fail ("NFKC entry %ld failed\n", i);
if (debug)
printf ("ERROR\n");
}
else if (debug)
printf ("OK\n");
free (out);
}
}
int main(int argc, char **argv)
{
unsigned char rule=0xD0;//0x7c;
unsigned char t;
unsigned long cells = 1;
unsigned long temp;
unsigned char index;
unsigned char ncells = 16;
if (argc > 1)
{
if(argv[1][0] == '0' && argv[1][1] == 'x')
{
unsigned int a;
sscanf(argv[1],"%x",&a);
rule = (unsigned char)a;
}
else
{
rule = atoi(argv[1]);
}
if (argc > 2)
{
if(argv[2][0] == '0' && argv[2][1] == 'x')
{
unsigned int a;
sscanf(argv[2],"%x",&a);
cells = (unsigned short)a;
}
else
{
cells = atoi(argv[2]);
}
}
}
else
{
printf("No argument! \n");
useage();
return;
}
ruleprint(rule);
printf("use ctl+C to stop \n");
ncells--;
for(;;cells=temp<<1|temp>>ncells)
{
binprint(cells,ncells);
temp=0;
for(index=0;index<=ncells;index++)
{
//the idea is to shift the rule mask (w/rollover) according to the 3
//bits in the neighborhood at $index, mask that bit in the rule to
//then determine the next cell state and OR it into a temp value
// |cell state-----------------------------------------------|
// | rule mask ---------------------------------|
// |neighborhood ---------------------------|
temp |= ((rule & 1<<((cells>>index|cells<<(ncells-index+1) )&7) )>0)<<index;
}
usleep(100000);
}
}
void
doit (void)
{
char *p;
int rc;
size_t i;
if (!stringprep_check_version (STRINGPREP_VERSION))
fail ("stringprep_check_version() failed\n");
for (i = 0; i < sizeof (strprep) / sizeof (strprep[0]); i++)
{
if (debug)
printf ("STRINGPREP entry %d\n", i);
if (debug)
{
printf ("flags: %d\n", strprep[i].flags);
printf ("in: ");
escapeprint (strprep[i].in, strlen (strprep[i].in));
hexprint (strprep[i].in, strlen (strprep[i].in));
binprint (strprep[i].in, strlen (strprep[i].in));
}
{
uint32_t *l;
char *x;
l = stringprep_utf8_to_ucs4 (strprep[i].in, -1, NULL);
x = stringprep_ucs4_to_utf8 (l, -1, NULL, NULL);
free (l);
if (strcmp (strprep[i].in, x) != 0)
{
fail ("bad UTF-8 in entry %d\n", i);
if (debug)
{
puts ("expected:");
escapeprint (strprep[i].in, strlen (strprep[i].in));
hexprint (strprep[i].in, strlen (strprep[i].in));
puts ("computed:");
escapeprint (x, strlen (x));
hexprint (x, strlen (x));
}
}
free (x);
}
rc = stringprep_profile (strprep[i].in, &p,
strprep[i].profile ?
strprep[i].profile :
"Nameprep", strprep[i].flags);
if (rc != strprep[i].rc)
{
fail ("stringprep() entry %d failed: %d\n", i, rc);
if (debug)
printf ("FATAL\n");
if (rc == STRINGPREP_OK)
free (p);
continue;
}
if (debug && rc == STRINGPREP_OK)
{
printf ("out: ");
escapeprint (p, strlen (p));
hexprint (p, strlen (p));
binprint (p, strlen (p));
printf ("expected out: ");
escapeprint (strprep[i].out, strlen (strprep[i].out));
hexprint (strprep[i].out, strlen (strprep[i].out));
binprint (strprep[i].out, strlen (strprep[i].out));
}
else if (debug)
printf ("returned %d expected %d\n", rc, strprep[i].rc);
if (rc == STRINGPREP_OK)
{
if (strlen (strprep[i].out) != strlen (p) ||
memcmp (strprep[i].out, p, strlen (p)) != 0)
{
fail ("stringprep() entry %d failed\n", i);
if (debug)
printf ("ERROR\n");
}
else if (debug)
printf ("OK\n\n");
free (p);
}
else if (debug)
printf ("OK\n\n");
}
#if 0
{
char p[20];
memset (p, 0, 10);
stringprep_unichar_to_utf8 (0x00DF, p);
hexprint (p, strlen (p));
puts ("");
}
#endif
}
void
test (Shishi * handle)
{
Shishi_key *key, *key2;
char out[BUFSIZ];
size_t i;
int res;
if (debug)
shishi_cfg (handle, strdup ("verbose-crypto,verbose-crypto-noise"));
for (i = 0; i < sizeof (drdk) / sizeof (drdk[0]); i++)
{
if (debug)
printf ("DR entry %d\n", i);
res = shishi_key_from_value (handle, drdk[i].type, drdk[i].key, &key);
if (res == SHISHI_OK)
res = shishi_dr (handle, key, drdk[i].usage, drdk[i].nusage,
out, strlen (drdk[i].dr));
shishi_key_done (key);
if (res != SHISHI_OK)
{
fail ("shishi_dr() entry %d failed (%s)\n",
i, shishi_error (handle));
continue;
}
if (debug)
{
printf ("DR(%s, key, usage)\n", shishi_cipher_name (drdk[i].type));
printf ("key:\n");
escapeprint (drdk[i].key, strlen (drdk[i].key));
hexprint (drdk[i].key, strlen (drdk[i].key));
puts ("");
binprint (drdk[i].key, strlen (drdk[i].key));
puts ("");
printf ("usage:\n");
escapeprint (drdk[i].usage, drdk[i].nusage);
hexprint (drdk[i].usage, drdk[i].nusage);
puts ("");
binprint (drdk[i].usage, drdk[i].nusage);
puts ("");
printf ("computed DR:\n");
escapeprint (out, strlen (drdk[i].dr));
hexprint (out, strlen (drdk[i].dr));
puts ("");
binprint (out, strlen (drdk[i].dr));
puts ("");
printf ("expected DR:\n");
escapeprint (drdk[i].dr, strlen (drdk[i].dr));
hexprint (drdk[i].dr, strlen (drdk[i].dr));
puts ("");
binprint (drdk[i].dr, strlen (drdk[i].dr));
puts ("");
}
if (memcmp (drdk[i].dr, out, strlen (drdk[i].dr)) != 0)
{
fail ("shishi_dr() entry %d failed\n", i);
if (debug)
printf ("ERROR\n");
}
else if (debug)
success ("OK\n");
res = shishi_key_from_value (handle, drdk[i].type, drdk[i].key, &key);
if (res == SHISHI_OK)
res = shishi_key_from_value (handle, drdk[i].type, NULL, &key2);
if (res == SHISHI_OK)
res = shishi_dk (handle, key, drdk[i].usage, drdk[i].nusage, key2);
shishi_key_done (key);
if (res != SHISHI_OK)
{
fail ("shishi_dk() entry %d failed (%s)\n",
i, shishi_error (handle));
continue;
}
if (debug)
{
printf ("DK(%s, key, usage)\n", shishi_cipher_name (drdk[i].type));
printf ("key:\n");
escapeprint (drdk[i].key, strlen (drdk[i].key));
hexprint (drdk[i].key, strlen (drdk[i].key));
puts ("");
binprint (drdk[i].key, strlen (drdk[i].key));
puts ("");
printf ("usage:\n");
escapeprint (drdk[i].usage, drdk[i].nusage);
hexprint (drdk[i].usage, drdk[i].nusage);
puts ("");
binprint (drdk[i].usage, drdk[i].nusage);
puts ("");
printf ("computed DK:\n");
escapeprint (shishi_key_value (key2), shishi_key_length (key2));
hexprint (shishi_key_value (key2), shishi_key_length (key2));
puts ("");
binprint (shishi_key_value (key2), shishi_key_length (key2));
puts ("");
printf ("expected DK:\n");
escapeprint (drdk[i].dk, strlen (drdk[i].dk));
hexprint (drdk[i].dk, strlen (drdk[i].dk));
puts ("");
binprint (drdk[i].dk, strlen (drdk[i].dk));
puts ("");
}
if (!(shishi_key_length (key2) == strlen (drdk[i].dk) &&
memcmp (drdk[i].dk, shishi_key_value (key2),
strlen (drdk[i].dk)) == 0))
{
fail ("shishi_dk() entry %d failed\n", i);
if (debug)
printf ("ERROR\n");
}
else if (debug)
success ("OK\n");
shishi_key_done (key2);
}
for (i = 0; i < sizeof (nfold) / sizeof (nfold[0]); i++)
{
if (debug)
printf ("N-FOLD entry %d\n", i);
res = shishi_n_fold (handle,
nfold[i].in, strlen (nfold[i].in),
out, nfold[i].n / 8);
if (res != SHISHI_OK)
{
fail ("shishi_n_fold() entry %d failed (%s)\n",
i, shishi_error (handle));
continue;
}
if (debug)
{
printf ("in:\n");
escapeprint (nfold[i].in, strlen (nfold[i].in));
hexprint (nfold[i].in, strlen (nfold[i].in));
puts ("");
binprint (nfold[i].in, strlen (nfold[i].in));
puts ("");
printf ("out:\n");
escapeprint (out, nfold[i].n / 8);
hexprint (out, nfold[i].n / 8);
puts ("");
binprint (out, nfold[i].n / 8);
puts ("");
printf ("expected out:\n");
escapeprint (nfold[i].out, nfold[i].n / 8);
hexprint (nfold[i].out, nfold[i].n / 8);
puts ("");
binprint (nfold[i].out, nfold[i].n / 8);
puts ("");
}
if (memcmp (nfold[i].out, out, nfold[i].n / 8) != 0)
{
fail ("shishi_n_fold() entry %d failed\n", i);
if (debug)
printf ("ERROR\n");
}
else if (debug)
success ("OK\n");
}
for (i = 0; i < sizeof (str2key) / sizeof (str2key[0]); i++)
{
int n_password = strlen (str2key[i].password);
int saltlen = strlen (str2key[i].salt);
int keylen = sizeof (key);
const char *name = shishi_cipher_name (str2key[i].etype);
if (debug)
printf ("STRING-TO-KEY entry %d (key type %s)\n", i,
name ? name : "NO NAME");
res = shishi_key_from_string (handle, str2key[i].etype,
str2key[i].password, n_password,
str2key[i].salt, saltlen,
str2key[i].parameters, &key);
if (res != SHISHI_OK)
{
fail ("shishi_string_to_key() entry %d failed (%s)\n",
i, shishi_error (handle));
continue;
}
if (debug)
{
printf ("password:\n");
escapeprint (str2key[i].password, n_password);
hexprint (str2key[i].password, n_password);
puts ("");
binprint (str2key[i].password, n_password);
puts ("");
printf ("salt:\n");
escapeprint (str2key[i].salt, saltlen);
hexprint (str2key[i].salt, saltlen);
puts ("");
binprint (str2key[i].salt, saltlen);
puts ("");
printf ("computed key:\n");
escapeprint (shishi_key_value (key), shishi_key_length (key));
hexprint (shishi_key_value (key), shishi_key_length (key));
puts ("");
binprint (shishi_key_value (key), shishi_key_length (key));
puts ("");
printf ("expected key:\n");
escapeprint (str2key[i].key, strlen (str2key[i].key));
hexprint (str2key[i].key, strlen (str2key[i].key));
puts ("");
binprint (str2key[i].key, strlen (str2key[i].key));
puts ("");
}
if (memcmp (str2key[i].key, shishi_key_value (key), keylen) != 0)
{
fail ("shishi_string_to_key() entry %d failed\n", i);
if (debug)
printf ("ERROR\n");
}
else if (debug)
success ("OK\n");
shishi_key_done (key);
}
for (i = 0; i < sizeof (pkcs5) / sizeof (pkcs5[0]); i++)
{
if (debug)
printf ("PKCS5 entry %d\n", i);
res = shishi_pbkdf2_sha1 (handle,
pkcs5[i].password, strlen (pkcs5[i].password),
pkcs5[i].salt, strlen (pkcs5[i].salt),
pkcs5[i].iterations, pkcs5[i].dklen, out);
if (res != SHISHI_OK)
{
fail ("PKCS5 entry %d failed fatally: %d\n", i, res);
continue;
}
if (debug)
{
printf ("password:\n");
escapeprint (pkcs5[i].password, strlen (pkcs5[i].password));
hexprint (pkcs5[i].password, strlen (pkcs5[i].password));
puts ("");
binprint (pkcs5[i].password, strlen (pkcs5[i].password));
puts ("");
printf ("salt:\n");
escapeprint (pkcs5[i].salt, strlen (pkcs5[i].salt));
hexprint (pkcs5[i].salt, strlen (pkcs5[i].salt));
puts ("");
binprint (pkcs5[i].salt, strlen (pkcs5[i].salt));
puts ("");
printf ("computed key:\n");
escapeprint (out, pkcs5[i].dklen);
hexprint (out, pkcs5[i].dklen);
puts ("");
binprint (out, pkcs5[i].dklen);
puts ("");
printf ("expected key:\n");
escapeprint (pkcs5[i].expected, pkcs5[i].dklen);
hexprint (pkcs5[i].expected, pkcs5[i].dklen);
puts ("");
binprint (pkcs5[i].expected, pkcs5[i].dklen);
puts ("");
}
if (memcmp (pkcs5[i].expected, out, pkcs5[i].dklen) != 0)
{
fail ("PKCS5 entry %d failed\n", i);
if (debug)
printf ("ERROR\n");
}
else if (debug)
success ("OK\n");
}
}
