int
dc_unscramble (void)
{
char dest_name[FILENAME_MAX];
strcpy (dest_name, ucon64.fname);
ucon64_file_handler (dest_name, NULL, 0);
if (!descramble (ucon64.fname, ucon64.file_size, dest_name))
printf (ucon64_msg[WROTE], dest_name);
else
fprintf (stderr, ucon64_msg[WRITE_ERROR], dest_name);
return 0;
}
int read_file(void)
/* Read in the file, return #bytes stored */
{
unsigned char rec[RECORD_LENGTH]; /* file record */
int byte_pointer=0;
/* Read in the file */
while((fread(rec,sizeof(unsigned char),RECORD_LENGTH,stdin)==RECORD_LENGTH)
&& (byte_pointer<MEMORY_SIZE))
{
/* convert each record to a register and store it */
descramble(rec,memory+byte_pointer);
byte_pointer+=REGISTER_LENGTH;
}
return(byte_pointer);
}
int main(int argc, char *argv[])
{
int opt = 0;
if(argc > 1 && !strcmp(argv[1], "-d"))
opt ++;
if(argc != 3+opt)
{
fprintf(stderr, "Usage: %s [-d] from to\n", argv[0]);
exit(1);
}
if(opt)
descramble(argv[2], argv[3]);
else
scramble(argv[1], argv[2]);
return 0;
}
/*
** Do a single prompt for a passphrase. Store the results in the blob.
**
** If the FOSSIL_PWREADER environment variable is set, then it will
** be the name of a program that prompts the user for their password/
** passphrase in a secure manner. The program should take one or more
** arguments which are the prompts and should output the acquired
** passphrase as a single line on stdout. This function will read the
** output using popen().
**
** If FOSSIL_PWREADER is not set, or if it is not the name of an
** executable, then use the C-library getpass() routine.
**
** The return value is a pointer to a static buffer that is overwritten
** on subsequent calls to this same routine.
*/
static void prompt_for_passphrase(
const char *zPrompt, /* Passphrase prompt */
int doScramble, /* Scramble the input if true */
char *zPassphrase /* Write result here */
){
char *z;
int i;
if( doScramble ){
generateScrambleCode();
z = getpass(zPrompt);
if( z ) descramble(z);
printf("\033[3A\033[J"); /* Erase previous three lines */
fflush(stdout);
}else{
z = getpass(zPrompt);
}
while( isspace(z[0]) ) z++;
for(i=0; i<MX_PASSPHRASE-1; i++){
zPassphrase[i] = z[i];
}
while( i>0 && isspace(z[i-1]) ){ i--; }
zPassphrase[i] = 0;
}
int main(int argc, char *argv[])
{
int opt = 0;
if(argc > 1 && !strcmp(argv[1], "-d"))
opt ++;
printf("DC Binary Scrambler\n");
if(argc != 3+opt)
{
/*fprintf(stderr, "Usage: %s [-d] from to\n", argv[0]);*/
printf("Usage: %s [-d] from to\n", argv[0]);
exit(1);
}
if(opt){
descramble(argv[2], argv[3]);
printf("\nDescrambling %s to ouptut file %s.\n", argv[2], argv[3]);
}else{
scramble(argv[1], argv[2]);
printf("\nScrambling %s to ouptut file %s.\n", argv[1], argv[2]);
}
return 0;
}
int
main( int argc, char **argv )
{
int i;
char *e, *m, biggie[256];
char *cleartexts[5];
cleartexts[0] = "first";
cleartexts[1] = "the second";
cleartexts[2] = "this is the third";
cleartexts[3] = "$#% !!\\3";
cleartexts[4] = biggie;
/* Set up the most important test string: */
/* Can't have a real ASCII zero in the string, because we want to
use printf, so we substitute the character zero. */
biggie[0] = '0';
/* The rest of the string gets straight ascending ASCII. */
for (i = 1; i < 256; i++)
biggie[i] = i;
/* Test all the strings. */
for (i = 0; i < 5; i++)
{
printf ("clear%d: %s\n", i, cleartexts[i]);
e = scramble (cleartexts[i]);
printf ("scram%d: %s\n", i, e);
m = descramble (e);
free (e);
printf ("clear%d: %s\n\n", i, m);
free (m);
}
fflush (stdout);
return 0;
}
struct zfile *read_rom (struct romdata **prd)
{
struct romdata *rd2 = *prd;
struct romdata *rd = *prd;
TCHAR *name;
int id = rd->id;
uae_u32 crc32;
int size;
uae_u8 *buf, *buf2;
/* find parent node */
for (;;) {
if (rd2 == &roms[0])
break;
if (rd2[-1].id != id)
break;
rd2--;
}
*prd = rd2;
size = rd2->size;
crc32 = rd2->crc32;
name = rd->name;
buf = xmalloc (uae_u8, size * 2);
memset (buf, 0xff, size * 2);
if (!buf)
return NULL;
buf2 = buf + size;
while (rd->id == id) {
int i, j, add;
int ok = 0;
uae_u32 flags = rd->type;
int odd = (flags & ROMTYPE_ODD) ? 1 : 0;
add = 0;
for (i = 0; i < 2; i++) {
memset (buf, 0, size);
if (!(flags & (ROMTYPE_EVEN | ROMTYPE_ODD))) {
read_rom_file (buf, rd);
if (flags & ROMTYPE_CD32) {
memcpy (buf2, buf, size);
mergecd32 (buf, buf2, size);
}
add = 1;
i++;
} else {
int romsize = size / 2;
if (i)
odd = !odd;
if (flags & ROMTYPE_8BIT) {
read_rom_file (buf2, rd);
if (flags & ROMTYPE_BYTESWAP)
byteswap (buf2, romsize);
if (flags & ROMTYPE_SCRAMBLED)
descramble (rd, buf2, romsize, odd);
for (j = 0; j < size; j += 2)
buf[j + odd] = buf2[j / 2];
read_rom_file (buf2, rd + 1);
if (flags & ROMTYPE_BYTESWAP)
byteswap (buf2, romsize);
if (flags & ROMTYPE_SCRAMBLED)
descramble (rd + 1, buf2, romsize, !odd);
for (j = 0; j < size; j += 2)
buf[j + (1 - odd)] = buf2[j / 2];
} else {
read_rom_file (buf2, rd);
if (flags & ROMTYPE_BYTESWAP)
byteswap (buf2, romsize);
if (flags & ROMTYPE_SCRAMBLED)
descramble (rd, buf2, romsize, odd);
for (j = 0; j < size; j += 4) {
buf[j + 2 * odd + 0] = buf2[j / 2 + 0];
buf[j + 2 * odd + 1] = buf2[j / 2 + 1];
}
read_rom_file (buf2, rd + 1);
if (flags & ROMTYPE_BYTESWAP)
byteswap (buf2, romsize);
if (flags & ROMTYPE_SCRAMBLED)
descramble (rd + 1, buf2, romsize, !odd);
for (j = 0; j < size; j += 4) {
buf[j + 2 * (1 - odd) + 0] = buf2[j / 2 + 0];
buf[j + 2 * (1 - odd) + 1] = buf2[j / 2 + 1];
}
}
add = 2;
}
if (get_crc32 (buf, size) == crc32) {
ok = 1;
}
if (!ok && (rd->type & ROMTYPE_AR)) {
uae_u8 tmp[2];
tmp[0] = buf[0];
tmp[1] = buf[1];
buf[0] = buf[1] = 0;
if (get_crc32 (buf, size) == crc32)
ok = 1;
buf[0] = tmp[0];
buf[1] = tmp[1];
}
if (!ok) {
/* perhaps it is byteswapped without byteswap entry? */
byteswap (buf, size);
if (get_crc32 (buf, size) == crc32)
ok = 1;
}
if (ok) {
struct zfile *zf = zfile_fopen_empty (NULL, name, size);
if (zf) {
zfile_fwrite (buf, size, 1, zf);
zfile_fseek (zf, 0, SEEK_SET);
}
xfree (buf);
return zf;
}
}
rd += add;
}
xfree (buf);
return NULL;
}
