static uint32_t synthSound (B3S *instance, uint32_t written, uint32_t nframes, float **out) {
B3S* b3s = (B3S*)instance;
while (written < nframes) {
int nremain = nframes - written;
if (b3s->boffset >= BUFFER_SIZE_SAMPLES) {
b3s->boffset = 0;
oscGenerateFragment (instance->inst->synth, b3s->bufA, BUFFER_SIZE_SAMPLES);
preamp (instance->inst->preamp, b3s->bufA, b3s->bufB, BUFFER_SIZE_SAMPLES);
reverb (instance->inst->reverb, b3s->bufB, b3s->bufC, BUFFER_SIZE_SAMPLES);
#ifdef WITH_SIGNATURE
scramble (b3s, b3s->bufC, BUFFER_SIZE_SAMPLES);
#endif
whirlProc3(instance->inst->whirl, b3s->bufC, b3s->bufL[0], b3s->bufL[1], b3s->bufD[0], b3s->bufD[1], BUFFER_SIZE_SAMPLES);
}
int nread = MIN(nremain, (BUFFER_SIZE_SAMPLES - b3s->boffset));
memcpy(&out[0][written], &b3s->bufL[0][b3s->boffset], nread*sizeof(float));
memcpy(&out[1][written], &b3s->bufL[1][b3s->boffset], nread*sizeof(float));
written+=nread;
b3s->boffset+=nread;
}
return written;
}
static void generateSignatureVector(DSA* key, unsigned char* mess, int len, BOOL passes)
{
unsigned char buf[len];
unsigned int siglen;
int err;
DSA_SIG* sig;
Mem::Copy(buf, mess, len);
setOurRandom();
sig = DSA_do_sign(buf, len, key);
if (sig == NULL)
processError();
if (!passes)
scramble(buf, len);
printActionHeader("DSA test vector", "DSASignVector");
printDSAPrivateKey(key);
printHexElement("digest", buf, len);
printBNElement("sigR", sig->r);
printBNElement("sigS", sig->s);
printActionFooter(passes);
printActionHeader("DSA test vector", "DSAVerifyVector");
printDSAPublicKey(key);
printHexElement("digest", buf, len);
printBNElement("sigR", sig->r);
printBNElement("sigS", sig->s);
printActionFooter(passes);
DSA_SIG_free(sig);
}
/* Decode the string in place. */
char *
descramble (char *str)
{
char *s;
int i;
/* For now we can only handle one kind of scrambling. In the future
there may be other kinds, and this `if' will become a `switch'. */
if (str[0] != 'A')
#ifndef DIAGNOSTIC
error (1, 0, "descramble: unknown scrambling method");
#else /* DIAGNOSTIC */
{
fprintf (stderr, "descramble: unknown scrambling method\n", str);
fflush (stderr);
exit (EXIT_FAILURE);
}
#endif /* DIAGNOSTIC */
/* Method `A' is symmetrical, so scramble again to decrypt. */
s = scramble (str + 1);
/* Shift the whole string one char to the left, pushing the unwanted
'A' off the left end. Safe, because s is null-terminated. */
for (i = 0; s[i]; i++)
s[i] = s[i + 1];
return s;
}
/*_____________________________________________________________________________
** function name: rand
** descriptions:
** Random value generation.
**
** parameters:
** None
**
** global:
** None
**
** return:
** Random value
**
** call:
** timerVlrGet
**
** revision:
** 1. Here 2008/08/24
**____________________________________________________________________________
*/
uint32
rand(void){
uint32 vlr;
timerVlrGet(1, vlr);
scramble(vlr);
return (vlr & RAND_MAX);
}/*end rand*/
int brute_cvsroot(void)
{
int i, ret = 0;
char * rbuf;
info("Bruteforcing cvsroot...\n");
for (i = 0; CVSROOTS[i].name; i++)
{
nopen(host, port);
nprintf(CVS_VERIF, CVSROOTS[i].name, DUMMY, scramble(DUMMY));
info("Trying CVSROOT = %s\t", CVSROOTS[i].name);
rbuf = flush_sock();
nclose();
if (!rbuf || strstr(rbuf, CVS_BAD_REP))
info(BAD_TRIP);
else if (strstr(rbuf, CVS_AUTH_FAILED) ||
strstr(rbuf, CVS_AUTH_SUCCESS) ||
strstr(rbuf, CVS_NO_USER))
{
info(GOOD_TRIP);
CVSROOTS[i].id = i;
root = CVSROOTS[i].name;
if (user && pass)
{
free(rbuf);
return (1);
}
ret++;
}
else
printf(BAD_TRIP);
free(rbuf);
}
return (ret);
}
/**
* Transmit APRS log packet
*/
uint32_t aprs_encode_log(uint8_t* message, mod_t mod)
{
ax25_t packet;
packet.data = message;
packet.max_size = 512; // TODO: replace 512 with real size
packet.mod = mod;
// Encode APRS header
ax25_send_header(&packet, APRS_CALLSIGN, APRS_SSID, APRS_PATH);
ax25_send_string(&packet, "{{L");
// Encode log message
uint8_t i;
for(i=0; i<LOG_TRX_NUM; i++) {
gpsFix_t dummy;
gpsFix_t *data = &dummy; // TODO: Implement getNextLogPoint() for this assignment
uint8_t base64[BASE64LEN(sizeof(gpsFix_t))+1];
base64_encode((uint8_t*)data, base64, sizeof(gpsFix_t));
ax25_send_string(&packet, (char*)base64);
}
// Send footer
ax25_send_footer(&packet);
nrzi_encode(&packet);
scramble(&packet);
return packet.size;
}
//*************************************************************
int main(void)
{
while (1) {
scramble(5, 5, 5) ;
getch() ;
}
// return 0;
}
static void fct_noscale(double *f)
{
scramble(f,N);
fwd_butterflies(f);
bitrev(f,N);
fwd_sums(f);
f[0] *= INVROOT2;
}
int
main(int argc, char **argv)
{
unsigned long mod;
hash_table_t table = HASH_TABLE_INIT(0x80010000 | HASH_FLAG_AUTOGROW,
check_func, check_comp, 0, 0);
/* Check that the static initializer produces a passable structure */
check_init(&table, HASH_FLAG_AUTOGROW, 0, 0, 0, check_func, check_comp,
0, "ht_static");
/* now, check what ht_init does with bad arguments */
check_result(ht_init(0, 0, 0, 0, 0, 0, 0), DB_ERR_BADARGS, "ht_init_noargs",
"ht_init() with no valid arguments", 0);
check_result(ht_init(0, 0, check_func, check_comp, 0, 0, 0), DB_ERR_BADARGS,
"ht_init_notable", "ht_init() with no table", 0);
check_result(ht_init(&table, 0, 0, check_comp, 0, 0, 0), DB_ERR_BADARGS,
"ht_init_nofunc", "ht_init() with no hash function", 0);
check_result(ht_init(&table, 0, check_func, 0, 0, 0, 0), DB_ERR_BADARGS,
"ht_init_nocomp", "ht_init() with no comparison function", 0);
/* Scramble the structure */
scramble(&table);
/* Now try to initialize our structure with a 0 mod and see what happens */
check_result(ht_init(&table, 0x80010000 | HASH_FLAG_AUTOGROW, check_func,
check_comp, 0, 0, 0), 0, "ht_dynamic_nomod",
"ht_init() with zero modulus", 0);
check_init(&table, HASH_FLAG_AUTOGROW, 0, 0, 0, check_func, check_comp,
0, "ht_dynamic_nomod");
/* Scramble the structure again */
scramble(&table);
/* Now try to initialize our structure with a non-0 mod and see what
* happens
*/
check_result(ht_init(&table, 0x80010000 | HASH_FLAG_AUTOGROW, check_func,
check_comp, 0, 0, 6), 0, "ht_dynamic_mod6",
"ht_init() with non-zero modulus", 0);
mod = 7; /* next prime after 6 */
check_init(&table, HASH_FLAG_AUTOGROW, mod, (mod * 4) / 3, (mod * 3) / 4,
check_func, check_comp, 0, "ht_dynamic_mod6");
return 0;
}
/* http://www.redferni.uklinux.net/mysql/MySQL-Protocol.html */
int MySQLPrepareAuth(_MYSQL_DATA *_psSessionData, char* szLogin, char* szPassword, char* szSessionSalt, unsigned char** szResponse, unsigned long* iResponseLength)
{
unsigned char* response;
/* usernames limited to 16 characters - http://dev.mysql.com/doc/refman/5.1/en/user-names.html */
int login_len = strlen(szLogin) > 16 ? 16 : strlen(szLogin);
int response_len = 4 /* header */ +
4 /* client flags */ +
4 /* max packet len */ +
1 /* charset */ +
23 /* future expansion */ +
login_len /* username */ +
1 /* NULL termination */ +
1; /* password length */
if ( strcmp(szPassword, "") != 0 ) /* password set */
response_len += 20;
response = (unsigned char *) malloc(response_len + 1);
memset(response, 0, response_len + 1);
response[0] = response_len - 4; /* packet body length - exclude header */
response[1] = 0x00;
response[2] = 0x00;
response[3] = 0x01; /* packet number */
//response[4] = 0x85; /* client flag */
response[4] = 0x05; /* client flag */
//response[5] = 0x24;
response[5] = 0xa6;
response[6] = 0x03;
response[7] = 0x00;
response[8] = 0x00; /* max packet */
response[9] = 0x00;
response[10] = 0x00;
response[11] = 0x01;
response[12] = 0x21; /* charset utf8 */
strncpy((char*)response + 36, szLogin, login_len); /* NULL terminated username */
if ( strcmp(szPassword, "") == 0 ) /* no password set */
{
response[36 + login_len + 1] = 0x00;
}
else
{
response[36 + login_len + 1] = 0x14; /* set length of scrambled password - 0x14 (20) */
/* generate SHA password hash */
scramble((char *) &response[36 + login_len + 1 + 1], _psSessionData, szSessionSalt, szPassword);
}
*(iResponseLength) = response_len;
*szResponse = response;
return SUCCESS;
}
int main(int argc, char **argv)
{
unsigned char *buf = (unsigned char *)argv[1];
int l = strlen((char *)buf);
printf("original :"); hexdump(buf, l);
scramble(buf, l);
printf("scrambled :"); hexdump(buf, l);
unscramble(buf, l);
printf("unscrambled:"); hexdump(buf, l);
}
TPuzzleView::TPuzzleView(TRect& r) :
TView(r) {
srand (time(NULL));options |= ofSelectable;
memset(board, ' ', sizeof(board));
for (int i = 0; i <= 3; i++)
for (int j = 0; j <= 3; j++)
board[i][j] = boardStart[i * 4 + j];
scramble();
}
static int
pcauth(int n, Rpccall *cmd, Rpccall *reply)
{
uchar *argptr = cmd->args;
uchar *dataptr = reply->results;
String sys, id, pw, cm;
Unixidmap *m;
int uid;
chat("host=%I, port=%ld: pcauth...",
cmd->host, cmd->port);
if(n <= 16)
return garbage(reply, "count too small");
argptr += string2S(argptr, &sys);
argptr += string2S(argptr, &id);
argptr += string2S(argptr, &pw);
argptr += string2S(argptr, &cm);
if(argptr != &((uchar *)cmd->args)[n])
return garbage(reply, "bad count");
scramble(&id);
scramble(&pw);
m = pair2idmap("pcnfsd", cmd->host);
uid = -1;
if(m)
uid = name2id(&m->u.ids, id.s);
if(uid < 0)
uid = 1;
chat("\"%.*s\",\"%.*s\",\"%.*s\",\"%.*s\"\n", utfnlen(sys.s, sys.n), sys.s,
utfnlen(id.s, id.n), id.s, utfnlen(pw.s, pw.n), pw.s, utfnlen(cm.s, cm.n), cm.s);
PLONG(0); /* status - OK */
PLONG(uid);
PLONG(uid); /* gid */
PLONG(0); /* ngids */
PLONG(sizeof(pc_home)-1);
PPTR(pc_home, sizeof(pc_home)-1);
PLONG(0); /* umask */
PLONG(sizeof(no_comment)-1);
PPTR(no_comment, sizeof(no_comment)-1);
return dataptr - (uchar *)reply->results;
}
int do_auth(void)
{
char * your_mind;
nopen(host, port);
nprintf(CVS_LOGIN, root, user, scramble(pass));
your_mind = flush_sock();
if (!strstr(your_mind, CVS_AUTH_SUCCESS))
QUIT(ERR_AUTHFAILED);
free(your_mind);
nprintf(CVS_SEND_ROOT, root);
}
/*
* Inverse Complex Fourier Transform
*/
void
icfft(COMPLEX *dat, int num)
{
/* Check for trig table initialization */
if (num != _init_size) {
if (init_sintab(num) == 0) {
/* Can't do requested size */
return;
}
}
scramble(num, dat);
butterflies(num, 1, dat);
}
int
dc_scramble (void)
{
char dest_name[FILENAME_MAX];
strcpy (dest_name, ucon64.fname);
ucon64_file_handler (dest_name, NULL, 0);
if (!scramble (ucon64.fname, ucon64.file_size, dest_name))
printf (ucon64_msg[WROTE], dest_name);
else
fprintf (stderr, ucon64_msg[WRITE_ERROR], dest_name);
return 0;
}
/**
* Transmit APRS telemetry configuration
*/
uint32_t aprs_encode_telemetry_configuration(uint8_t* message, mod_t mod, telemetryConfig_t type)
{
char temp[4];
ax25_t packet;
packet.data = message;
packet.max_size = 512; // TODO: replace 512 with real size
packet.mod = mod;
ax25_send_header(&packet, APRS_CALLSIGN, APRS_SSID, APRS_PATH); // Header
ax25_send_byte(&packet, ':'); // Message flag
// Callsign
ax25_send_string(&packet, APRS_CALLSIGN);
ax25_send_byte(&packet, '-');
chsnprintf(temp, sizeof(temp), "%d", APRS_SSID);
ax25_send_string(&packet, temp);
ax25_send_string(&packet, " :"); // Message separator
switch(type) {
case CONFIG_PARM:
ax25_send_string(&packet, "PARM.Battery,Solar,Temp,Charge,Discharge");
break;
case CONFIG_UNIT:
ax25_send_string(&packet, "UNIT.Volt,Volt,degC,mW,mW");
break;
case CONFIG_EQNS:
ax25_send_string(&packet,
"EQNS."
"0,.001,0,"
"0,.001,0,"
"0,0.1,-100,"
"0,1,0,"
"0,1,0"
);
break;
case CONFIG_BITS:
ax25_send_string(&packet, "BITS.11111111,Pecan Balloon");
break;
}
ax25_send_footer(&packet); // Footer
nrzi_encode(&packet);
scramble(&packet);
return packet.size;
}
/*
* The main function.
* @param argc The number of arguments.
* @param argv The arguments themselves, in an arrag of strings (char *).
* @return The exit value (EXIT_SUCCESS or EXIT_FAILURE).
*/
int
main (int argc, char **argv)
{
FILE *io_pipes[2];
#ifdef ENABLE_NLS
bindtextdomain (PACKAGE, LOCALEDIR);
bind_textdomain_codeset (PACKAGE, "UTF-8");
textdomain (PACKAGE);
#endif
seed (NULL);
scramble (options (argc, argv, io_pipes), io_pipes);
return EXIT_SUCCESS;
}
int do_attack(MYSQL *mysql, char *attackuser) {
char buff[512], *pos=buff, *attackpasswd = "A";
int i, len, j, ret = 1;
pos = (char*)strmov(pos,attackuser)+1;
mysql->scramble_buff[1] = 0;
pos = scramble(pos, mysql->scramble_buff, attackpasswd,
(my_bool) (mysql->protocol_version == 9));
pos = (char*)strmov(pos+1,"");
len = pos-buff;
for (j = 0; ret && j < 32; j++) {
buff[5] = 65 + j;
ret = simple_command(mysql,COM_CHANGE_USER, buff,(uint)len,0);
}
return ret;
}
void TPuzzleView::handleEvent(TEvent& event) {
TView::handleEvent(event);
if (solved && (event.what & (evKeyboard | evMouse))) {
scramble();
clearEvent(event);
}
if (event.what == evMouseDown) {
moveTile(event.mouse.where);
clearEvent(event);
winCheck();
} else if (event.what == evKeyDown) {
moveKey(event.keyDown.keyCode);
clearEvent(event);
winCheck();
}
}
int brute_username(void)
{
int i, c, ret = 0;
char * rbuf;
info("Bruteforcing cvs login... \n");
for (c = 0; CVSROOTS[c].name; c++)
{
if (!root && CVSROOTS[c].id == -1) continue;
for ( i=0; USERNAMES[i].name; i++ )
{
if (root)
CVSROOTS[c].name = root;
info("Trying cvsroot = %s, login = %s\t", CVSROOTS[c].name,
USERNAMES[i].name);
nopen(host, port);
nprintf(CVS_VERIF, CVSROOTS[c].name, USERNAMES[i].name,
scramble(DUMMY));
rbuf = flush_sock();
nclose();
if ( strstr( rbuf, CVS_NO_USER))
info( BAD_TRIP, rbuf );
else if (strstr( rbuf, CVS_AUTH_FAILED) ||
strstr(rbuf, CVS_AUTH_SUCCESS))
{
info(GOOD_TRIP);
USERNAMES[i].id = CVSROOTS[c].id;
user = USERNAMES[i].name;
if (pass)
{
free(rbuf);
return (1);
}
ret++;
}
free(rbuf);
}
if (root)
return (ret);
}
return (ret);
}
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;
}
int brute_password(void)
{
int i, c, ret=0;
char * rbuf;
info("Bruteforcing cvs password...\n");
for (c = 0; USERNAMES[c].name; c++)
{
if (!user && USERNAMES[c].id == -1) continue;
for (i = 0; PASSWORDS[i].name; i++)
{
info("Trying login = %s, pass = %s\t", user?user:USERNAMES[c].name,
PASSWORDS[i].name);
nopen(host, port);
nprintf(CVS_VERIF,root?root:CVSROOTS[USERNAMES[c].id].name,
user?user:USERNAMES[c].name, scramble(PASSWORDS[i].name) );
rbuf = flush_sock();
nclose();
if (strstr(rbuf, CVS_AUTH_FAILED))
info(BAD_TRIP, rbuf);
else if (strstr(rbuf, CVS_AUTH_SUCCESS))
{
info(GOOD_TRIP);
if (!root)
root = CVSROOTS[ USERNAMES[c].id ].name;
if (!user)
user = USERNAMES[c].name;
pass = PASSWORDS[i].name;
free(rbuf);
printf(SUCCESS_LOGON, user, pass, root);
return (1);
}
else
info(BAD_TRIP);
free(rbuf);
}
if (user)
return (0);
}
return (0);
}
int createP2mFile(FILE *fp, u8 *bin, u32 binlen, u32 *p2mlen)
{
P2M_DIR *dir = newP2mDir(P2M_GAMENAME, P2M_ROOTNAME);
if (dir == NULL) return -1;
if (addP2mDirFile(dir, "icon.sys", icon_sys, sizeof(icon_sys)) < 0) return -2;
if (addP2mDirFile(dir, "fcd.ico", fcd_ico, sizeof(fcd_ico)) < 0) return -2;
if (addP2mDirFile(dir, P2M_FILENAME, bin, binlen) < 0) return -2;
fwrite(P2M_FILE_ID, sizeof(char), strlen(P2M_FILE_ID), fp);
scramble(dir);
writeP2mDir(dir, fp);
put_u32(0, fp); // No further dirs
*p2mlen = dir->dirhdr->totalsize + 12;
freeP2mDir(dir);
return 0;
}
uint32_t aprs_encode_image(uint8_t* message, mod_t mod, uint8_t *image, size_t size)
{
ax25_t packet;
packet.data = message;
packet.max_size = 512; // TODO: replace 512 with real size
packet.mod = mod;
// Encode APRS header
ax25_send_header(&packet, APRS_CALLSIGN, APRS_SSID, NULL);
ax25_send_string(&packet, "{{I");
// Encode image message
for(uint16_t i=0; i<size; i++)
ax25_send_byte(&packet, image[i]);
// Send footer
ax25_send_footer(&packet);
nrzi_encode(&packet);
scramble(&packet);
return packet.size;
}
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;
}
REQUEST\n"
#define REQUEST "Root %s\n"
void login(char *login, char *password, char *repo)
{
char *buf, *ptr, reply[1024];
char *rep, *rp;
buf = (char *)malloc(1024);
rep = (char *)malloc(512);
ptr = buf;
rp = rep;
sprintf(ptr, LOGIN, login, scramble(password));
sprintf(rp, REQUEST, repo);
ptr = buf;
xp_write(ptr); /* login request */
xp_receive();
xp_write(rp); /* root dir request */
}
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;
}
int main(void)
{
const int N = 50;
int i, cnt, action;
char ch;
Row data[N];
Key key;
FILE *file = fopen("input.txt", "r");
if (file == NULL)
{
printf("Ошибка при открытии файла\n");
return 0;
}
i = 0;
while (i < N && fscanf(file, "%hd %hd", &data[i].key.a, &data[i].key.b) == 2)
{
fscanf(file, "%c", &ch);
getRow(file, data[i].val, sizeof(data[i].val));
i++;
}
fclose(file);
cnt = i;
do
{
printf("Меню\n");
printf("1) Печать\n");
printf("2) Двоичный поиск\n");
printf("3) Сортировка\n");
printf("4) Перемешивание\n");
printf("5) Реверс\n");
printf("6) Выход\n");
printf("Выберите действие\n");
scanf("%d", &action);
switch (action)
{
case 1:
{
printTable(data, cnt);
break;
}
case 2:
{
if (!isSorted(data, cnt))
printf("Ошибка. Таблица не отсортирована\n");
else
{
printf("Введите ключ: ");
scanf("%hd %hd", &key.a, &key.b);
i = binSearch(data, cnt, key);
if (i > -1)
printf("Найдена строка: %s\n", data[i].val);
else
printf("Строка с таким ключом не найдена\n");
}
break;
}
case 3:
{
sort(data, cnt);
break;
}
case 4:
{
scramble(data, cnt);
break;
}
case 5:
{
reverse(data, cnt);
break;
}
case 6: break;
default:
{
printf("Ошибка. Такого пункта меню не существует\n");
break;
}
}
}
while (action != 6);
return 0;
}
inline QString unscramble64(QString in)
{
return scramble(unbase64(in));
}
