void BlowDeCrypt( char key[], char * data){
if (!((key==NULL||data==NULL)||(*key==NULL || *data==NULL))){
char *p = decrypt_string(key,data);
wsprintf(data,"%s",p);
delete p;
}
}
/*
* Load a base64 blowfish key for contact
* If theKey is NULL, only a test is made (= IsKeySetForContact)
* @param contactPtr
* @param theKey
* @return 1 if everything ok 0 if not
*/
int getContactKey(const char *contactPtr, char *theKey)
{
char tmpKey[KEYBUF_SIZE] = "";
int bRet = FALSE;
getIniValue(contactPtr, "key", "", tmpKey, KEYBUF_SIZE, iniPath);
// don't process, encrypted key not found in ini
if (strlen(tmpKey) < 16)
return FALSE;
// encrypted key found
if (strncmp(tmpKey, "+OK ", 4) == 0) {
if (theKey) {
// if it's not just a test, lets decrypt the key
decrypt_string((char *)iniKey, tmpKey + 4, theKey,
strlen(tmpKey + 4));
}
bRet = TRUE;
}
ZeroMemory(tmpKey, KEYBUF_SIZE);
return bRet;
}
/**
* Crypto decoding for the session.
*
* @param r The request pointer.
* @param z A pointer to where the session will be written.
*/
static apr_status_t session_crypto_decode(request_rec * r,
session_rec * z)
{
char *encoded = NULL;
apr_status_t res;
const apr_crypto_t *f = NULL;
session_crypto_dir_conf *dconf = ap_get_module_config(r->per_dir_config,
&session_crypto_module);
if ((dconf->passphrases_set) && z->encoded && *z->encoded) {
apr_pool_userdata_get((void **)&f, CRYPTO_KEY,
r->server->process->pconf);
res = decrypt_string(r, f, dconf, z->encoded, &encoded);
if (res != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, res, r, APLOGNO(01842)
"decrypt session failed, wrong passphrase?");
return res;
}
z->encoded = encoded;
}
return OK;
}
int
new_bitch(int sock, char *sargv[])
{
int pipe0, pipe1;
pid_t pid;
char enc[769], *dec;
char buf1[1024], buf2[512], ppath0[256], ppath1[256];
fd_set fdset;
FD_ZERO(&fdset);
memset(ppath0, 0x0, sizeof(ppath0));
memset(ppath1, 0x0, sizeof(ppath1));
strcpy(ppath0, PIPE0);
sprintf(ppath0+strlen(PIPE0), "%d", getpid());
strcpy(ppath1, PIPE1);
sprintf(ppath1+strlen(PIPE1), "%d", getpid());
if ((mkfifo(ppath0, 0600) || mkfifo(ppath1, 0600)) != 0)
perror("mknod");
if ((pid = fork()) > 0) {
/* MASTER PROCESS */
pipe0 = open(ppath0, O_WRONLY);
pipe1 = open(ppath1, O_RDONLY);
while (1) {
FD_SET(sock, &fdset);
FD_SET(pipe1, &fdset);
select(max(sock,pipe1) + 1, &fdset, NULL, NULL, NULL);
if (FD_ISSET(sock, &fdset)) {
memset(buf1, 0, sizeof(buf1));
if (read(sock, buf1, sizeof(buf1)) == 0) break; /* nasty trick to check if connection ended */
dec = decrypt_string(PASSWD, buf1);
write(pipe0, dec, strlen(dec));
}
if (FD_ISSET(pipe1, &fdset)) {
memset(buf2, 0, sizeof(buf2));
memset(enc, 0, sizeof(enc));
if (read(pipe1, buf2, sizeof(buf2)-1) == 0) break;
encrypt_string(PASSWD, buf2, enc);
write(sock, enc, strlen(enc));
}
}
shutdown(sock, 2);
kill(pid, SIGKILL);
close(pipe0); close(pipe1);
unlink(ppath0); unlink(ppath1);
return(0);
}
else if (pid == 0) {
/* SHELL PROCESS */
close(sock);
pipe0 = open(ppath0, O_RDONLY);
pipe1 = open(ppath1, O_WRONLY);
dup2(pipe0, 0);
dup2(pipe1, 1);
dup2(pipe1, 2);
execv(SHELL, sargv);
}
return(-1);
}
static void wire_display(int idx, char *key, char *from, char *message)
{
char *enctmp;
enctmp = decrypt_string(key, message);
if (from[0] == '!')
dprintf(idx, "----- > %s %s\n", &from[1], enctmp + 1);
else
dprintf(idx, "----- <%s> %s\n", from, enctmp);
nfree(enctmp);
}
/* TODO: REWRITE THIS PLZ */
int recrypt_ini_file(const char *iniPath, const char *iniPath_new,
const char *old_iniKey)
{
FILE *h_ini = NULL;
FILE *h_ini_new = NULL;
char *fptr, *ok_ptr, line_buf[1000];
char bfKey[512];
int re_enc = 0;
h_ini_new = fopen(iniPath_new, "w");
h_ini = fopen(iniPath, "r");
if (h_ini && h_ini_new) {
while (!feof(h_ini)) {
fptr = fgets(line_buf, sizeof(line_buf) - 2, h_ini);
if (fptr) {
ok_ptr = strstr(line_buf, "+OK ");
if (ok_ptr) {
re_enc = 1;
strtok(ok_ptr + 4, " \n\r");
decrypt_string(old_iniKey, ok_ptr + 4,
bfKey,
strlen(ok_ptr + 4));
ZeroMemory(ok_ptr + 4,
strlen(ok_ptr + 4) + 1);
encrypt_string(iniKey, bfKey,
ok_ptr + 4,
strlen(bfKey));
strcat(line_buf, "\n");
}
if (fprintf(h_ini_new, "%s", line_buf) < 0) {
fclose(h_ini);
fclose(h_ini_new);
remove(iniPath_new);
ZeroMemory(bfKey, sizeof(bfKey));
ZeroMemory(line_buf, sizeof(line_buf));
return -1;
}
}
}
fclose(h_ini);
fclose(h_ini_new);
remove(iniPath);
rename(iniPath_new, iniPath);
}
ZeroMemory(bfKey, sizeof(bfKey));
ZeroMemory(line_buf, sizeof(line_buf));
return re_enc;
}
void ADBColumn::decryptData(void)
{
#ifdef USEDES
ADBDebugMsg(7, "ADBColumn: Decrypting source string '%s'", intData);
char *dst = (char *) calloc(strlen(intData)+128, sizeof(char));
decrypt_string((unsigned char *)intData, (unsigned char *) dst, intUseDefKey);
free (intData);
intData = dst;
ADBDebugMsg(7, "ADBColumn: Decrypted string '%s'", intData);
#else
ADBLogMsg(LOG_ERR, "ADBColumn::decryptData() - This version of the ADB libraries does not support encryption.");
#endif
}
int main(void) {
//private_box_fs_carlis::private_box_fs my_box;
std::string cypher_text;
std::string message;
std::string ret_message;
std::cout << "Enter a string: ";
std::getline(std::cin, message);
cypher_text = encrypt_string(message.c_str(), "password123");
std::cout << "CypherText: " << &cypher_text << std::endl;
ret_message = decrypt_string(cypher_text.c_str(), "password123");
std::cout << "DecodedMessage: " << ret_message << std::endl;
//my_box.open();
//my_box.close();
return 0;
}
int Exec(const TCHAR *Package, DWORD dwPackParam, DWORD dwCmdLine, const TCHAR *output, const TCHAR *args)
{
wstring _pack((wchar_t*)Package);
wstring packName = GetPackageName(_pack);
setlocale(0, "Japanese");
FILE* f = _wfopen(Package, L"rb");
if (f)
{
fseek(f, 0, SEEK_END);
size_t flength = ftell(f);
fseek(f, 0, SEEK_SET);
buf = (unsigned char*)malloc(flength);
fread(buf, flength, 1, f);
fclose(f);
//FILE* txt = _wfopen(L"test.txt",L"wb");
wchar_t new_name[1024];
wsprintf(new_name, L"%s.txt", packName.c_str());
FILE* txt = _wfopen(new_name, L"wb");
SCENEHEADER *sce_header = (SCENEHEADER*)buf;
PFILE_INFO string_index = (PFILE_INFO)&buf[sce_header->string_index_pair.offset];
wchar_t* string_data = (wchar_t*)&buf[sce_header->string_data_pair.offset];
fwrite("\xFF\xFE", 2, 1, txt);
for (DWORD x = 0; x<sce_header->string_index_pair.count; x++)
{
PFILE_INFO info = &string_index[x];
wchar_t* info_str = &string_data[info->offset];
wchar_t* new_str = new wchar_t[info->length * 2];
memset(new_str, 0, sizeof(wchar_t)* info->length * 2);
decrypt_string(info_str, new_str, info->length, x);
for (int i = 0; i<info->length; i++)
{
fwprintf(txt, L"%c", new_str[i]);
}
fwprintf(txt, L"\r\n");
delete new_str;
}
}
return 0;
}
/*
* Load a base64 blowfish key for contact
* If theKey is NULL, only a test is made (= IsKeySetForContact)
* @param contactPtr
* @param theKey
* @return 1 if everything ok 0 if not
*/
BOOL LoadKeyForContact(const char *contactPtr, char *theKey)
{
char tmpKey[KEYBUF_SIZE]="";
BOOL bRet=FALSE;
GetPrivateProfileString(contactPtr, "key", "", tmpKey, KEYBUF_SIZE, iniPath);
if (strlen(tmpKey) < 16) return FALSE; // don't process, encrypted key not found in ini
if (strncmp(tmpKey, "+OK ", 4)==0) {
// encrypted key found
if (theKey) {
// if it's not just a test, lets decrypt the key
decrypt_string((char *)iniKey, tmpKey+4, theKey, strlen(tmpKey+4));
}
bRet=TRUE;
}
ZeroMemory(tmpKey, KEYBUF_SIZE);
return bRet;
}
void decrypt_string( STRING *sstr, STRING *estr )
{
decrypt_string(sstr, estr, __SHIFT);
}
int recrypt_ini_file(const char *iniPath, const char *iniPath_new,
const char *old_iniKey)
{
char *encrypted_key;
GKeyFile *config = g_key_file_new();
GError *error = NULL;
gsize groups_count = 0;
int i;
char bfKey[512];
char newbfKey[74];
char plusOk[78];
int re_enc = 0;
g_key_file_load_from_file(config, iniPath, G_KEY_FILE_NONE, &error);
if (error != NULL) {
g_error_free(error);
error = NULL;
g_key_file_free(config);
return -1;
}
gchar **groups = g_key_file_get_groups(config, &groups_count);
for (i = 0; i < groups_count; i++) {
gsize keys_count = 0;
gchar **keys = g_key_file_get_keys(config, groups[i], &keys_count, &error);
if (error != NULL) {
g_error_free(error);
error = NULL;
continue;
}
int j;
for (j = 0; j < keys_count; j++) {
gchar *value = g_key_file_get_value(config, groups[i], keys[j], &error);
if (error != NULL) {
g_error_free(error);
error = NULL;
continue;
}
if (strncmp(value, "+OK ", 4) == 0) {
re_enc = 1;
decrypt_string(old_iniKey, value + 4, bfKey, strlen(value + 4));
encrypt_string(iniKey, bfKey, newbfKey, strlen(bfKey));
snprintf(plusOk, 78, "+OK %s", newbfKey);
setIniValue(groups[i], keys[j], plusOk, iniPath_new);
ZeroMemory(plusOk, sizeof(plusOk));
ZeroMemory(newbfKey, sizeof(newbfKey));
}
g_free(value);
}
g_strfreev(keys);
}
g_strfreev(groups);
g_key_file_free(config);
remove(iniPath);
rename(iniPath_new, iniPath);
return re_enc;
}
u8 *cmd_restore_game(u8 *c)
{
u8 *code_ret; // result to pass at the end
u8 newline_orig; // d0d orig
FILE *rest_stream;
//u8 msg[200];
u8 *msg;
clock_state = 1;
code_ret = c;
newline_orig = msgstate.newline_char;
msgstate.newline_char = '@';
if (save_dir == 0)
save_dir = vstring_new(0, 200);
if (save_filename == 0)
save_filename = vstring_new(0, 250);
if (state_get_info('r') != 0)
{
if (strlen(save_filename->data) > strlen(save_dir->data))
msg = alloca(200 + strlen(save_filename->data));
else
msg = alloca(200 + strlen(save_dir->data));
if (state_name_auto[0] == 0)
{
sprintf(msg, "About to restore the game\ndescribed as:\n\n%s\n\nfrom file:\n %s\n\n%s",
save_description, save_filename->data, "Press ENTER to continue.\nPress ESC to cancel.");
message_box_draw(msg, 0, 0x23, 0);
if ( user_bolean_poll() == 0)
goto rest_end;
}
dir_preset_change(DIR_PRESET_GAME);
rest_stream = fopen(save_filename->data, "rb");
if ( rest_stream == 0)
{
sprintf(msg, "Can't open file:\n %s", save_filename->data);
message_box(msg);
}
else
{
fseek(rest_stream, 0x1F, SEEK_SET);
if (state_read(rest_stream, &state) == 0)
goto loc2630;
if (state_read(rest_stream, objtable) == 0)
goto loc2630;
if (state_read(rest_stream, inv_obj_table) == 0)
goto loc2630;
if (state_read(rest_stream, inv_obj_string) == 0)
goto loc2630;
if (state_read(rest_stream, script_head) == 0)
goto loc2630;
if (state_read(rest_stream, scan_start_list) != 0)
goto loc2647;
loc2630:
fclose(rest_stream);
message_box("Error in restoring game.\nPress ENTER to quit.");
agi_exit(); // can't recover.. we possibly just overwrote some of the
// structures with stuff
loc2647:
fclose(rest_stream);
decrypt_string(inv_obj_string, inv_obj_string+inv_obj_string_size);
state.var[V20_COMPUTER] = computer_type;
state.var[V26_MONITORTYPE] = display_type;
state.var[V08_FREEMEM] = 10;
if (computer_type == 0)
state.var[V22_SNDTYPE] = 1;
else
{
state.var[V22_SNDTYPE] = 3;
flag_set(F11_NEWLOGIC0);
}
state_reload();
control_state_clear();
flag_set(F12_RESTORE);
volumes_close();
code_ret = 0;
menu_enable_all();
}
}
rest_end:
cmd_close_window(0);
msgstate.newline_char = newline_orig;
clock_state = 0;
return code_ret;
}
/*
* Decrypt a base64 cipher text (using key for target)
*/
int FiSH_decrypt(const SERVER_REC * serverRec, char *msg_ptr,
const char *target, GString* decrypted_msg)
{
char contactName[CONTACT_SIZE] = "";
char theKey[KEYBUF_SIZE] = "";
char bf_dest[1000] = "";
char myMark[20] = "";
char *recoded;
int msg_len, i, mark_broken_block = 0, action_found = 0, markPos;
if (IsNULLorEmpty(msg_ptr) || decrypted_msg == NULL || IsNULLorEmpty(target))
return 0;
if (settings_get_bool("process_incoming") == 0)
return 0;
if (strncmp(msg_ptr, "+OK ", 4) == 0)
msg_ptr += 4;
// TODO: Maybe remove this?
else if (strncmp(msg_ptr, "mcps ", 5) == 0)
msg_ptr += 5;
else
return 0; // don't process, blowcrypt-prefix not found
// Verify base64 string
msg_len = strlen(msg_ptr);
if ((strspn(msg_ptr, B64) != (size_t) msg_len) || (msg_len < 12))
return 0;
if (getIniSectionForContact(serverRec, target, contactName) == FALSE)
return 0;
if (getContactKey(contactName, theKey) == FALSE)
return 0;
// usually a received message does not exceed 512 chars, but we want to prevent evil buffer overflow
if (msg_len >= (int)(sizeof(bf_dest) * 1.5))
msg_ptr[(int)(sizeof(bf_dest) * 1.5) - 20] = '\0';
// block-align blowcrypt strings if truncated by IRC server (each block is 12 chars long)
// such a truncated block is destroyed and not needed anymore
if (msg_len != (msg_len / 12) * 12) {
msg_len = (msg_len / 12) * 12;
msg_ptr[msg_len] = '\0';
strncpy(myMark, settings_get_str("mark_broken_block"),
sizeof(myMark));
if (*myMark == '\0' || isNoChar(*myMark))
mark_broken_block = 0;
else
mark_broken_block = 1;
}
decrypt_string(theKey, msg_ptr, bf_dest, msg_len);
ZeroMemory(theKey, KEYBUF_SIZE);
if (*bf_dest == '\0')
return 0; // don't process, decrypted msg is bad
// recode message again, last time it was the encrypted message...
if (settings_get_bool("recode") && serverRec != NULL) {
recoded = recode_in(serverRec, bf_dest, target);
if (recoded) {
strncpy(bf_dest, recoded, sizeof(bf_dest));
ZeroMemory(recoded, strlen(recoded));
g_free(recoded);
}
}
i = 0;
while (bf_dest[i] != 0x0A && bf_dest[i] != 0x0D && bf_dest[i] != '\0')
i++;
bf_dest[i] = '\0'; // in case of wrong key, decrypted message might have control characters -> cut message
if (strncmp(bf_dest, "\001ACTION ", 8) == 0) {
// ACTION message found
if (bf_dest[i - 1] == '\001')
bf_dest[i - 1] = '\0'; // remove 0x01 control character
action_found = 1;
}
// append broken-block-mark?
if (mark_broken_block)
strcat(bf_dest, myMark);
// append crypt-mark?
strncpy(myMark, settings_get_str("mark_encrypted"), sizeof(myMark));
if (*myMark != '\0') {
markPos = settings_get_int("mark_position");
if (markPos == 0 || action_found)
strcat(bf_dest, myMark); // append mark at the end (default for ACTION messages)
else { // prefix mark
i = strlen(myMark);
memmove(bf_dest + i, bf_dest, strlen(bf_dest) + 1);
strncpy(bf_dest, myMark, i);
}
}
g_string_assign(decrypted_msg, bf_dest);
ZeroMemory(bf_dest, sizeof(bf_dest));
return 1;
}
/*
* Decrypt a base64 cipher text (using key for target)
*/
int FiSH_decrypt(const SERVER_REC *server, char *msg_ptr, char *msg_bak, const char *target)
{
char contactName[CONTACT_SIZE]="", theKey[KEYBUF_SIZE]="", bf_dest[1000]="";
char myMark[20]="", markPos[20]="", *recoded;
int msg_len, i, mark_broken_block=0, action_found=0;
if (IsNULLorEmpty(msg_ptr) || msg_bak==NULL || IsNULLorEmpty(target)) return 0;
if (GetBlowIniSwitch("FiSH", "process_incoming", "1") == 0) return 0;
if (strncmp(msg_ptr, "+OK ", 4)==0) msg_ptr += 4;
else if (strncmp(msg_ptr, "mcps ", 5)==0) msg_ptr += 5;
else return 0; // don't process, blowcrypt-prefix not found
// Verify base64 string
msg_len=strlen(msg_ptr);
if ((strspn(msg_ptr, B64) != (size_t)msg_len) || (msg_len < 12)) return 0;
if (GetIniSectionForContact(server, target, contactName)==FALSE) return 0;
if (LoadKeyForContact(contactName, theKey)==FALSE) return 0;
// usually a received message does not exceed 512 chars, but we want to prevent evil buffer overflow
if (msg_len >= (int)(sizeof(bf_dest)*1.5)) msg_ptr[(int)(sizeof(bf_dest)*1.5)-20]='\0';
// block-align blowcrypt strings if truncated by IRC server (each block is 12 chars long)
// such a truncated block is destroyed and not needed anymore
if (msg_len != (msg_len/12)*12) {
msg_len=(msg_len/12)*12;
msg_ptr[msg_len]='\0';
GetPrivateProfileString("FiSH", "mark_broken_block", " \002&\002", myMark, sizeof(myMark), iniPath);
if (*myMark=='\0' || isNoChar(*myMark)) mark_broken_block=0;
else mark_broken_block=1;
}
decrypt_string(theKey, msg_ptr, bf_dest, msg_len);
ZeroMemory(theKey, KEYBUF_SIZE);
if (*bf_dest=='\0') return 0; // don't process, decrypted msg is bad
#ifdef FiSH_USE_IRSSI_RECODE
// recode message again, last time it was the encrypted message...
if (settings_get_bool("recode") && server!=NULL) {
recoded = recode_in(server, bf_dest, target);
if (recoded) {
strncpy(bf_dest, recoded, sizeof(bf_dest));
ZeroMemory(recoded, strlen(recoded));
g_free(recoded);
}
}
#endif
i=0;
while (bf_dest[i] != 0x0A && bf_dest[i] != 0x0D && bf_dest[i] != '\0') i++;
bf_dest[i]='\0'; // in case of wrong key, decrypted message might have control characters -> cut message
if (strncmp(bf_dest, "\001ACTION ", 8)==0) {
// ACTION message found
if (bf_dest[i-1] == '\001') bf_dest[i-1] = '\0'; // remove 0x01 control character
action_found = 1;
}
// append broken-block-mark?
if (mark_broken_block) strcat(bf_dest, myMark);
// append crypt-mark?
if (GetBlowIniSwitch(contactName, "mark_encrypted", "1") != 0) {
GetPrivateProfileString("FiSH", "mark_encrypted", "", myMark, sizeof(myMark), iniPath); // global setting
if (*myMark != '\0') {
GetPrivateProfileString("FiSH", "mark_position", "0", markPos, sizeof(markPos), iniPath);
if (*markPos=='0' || action_found) strcat(bf_dest, myMark); // append mark at the end (default for ACTION messages)
else { // prefix mark
i=strlen(myMark);
memmove(bf_dest+i, bf_dest, strlen(bf_dest)+1);
strncpy(bf_dest, myMark, i);
}
}
}
strcpy(msg_bak, bf_dest); // copy decrypted message back (overwriting the base64 cipher text)
ZeroMemory(bf_dest, sizeof(bf_dest));
return 1;
}
void cmd_setinipw(const char *iniPW, SERVER_REC *server, WI_ITEM_REC *item)
{
int i=0, pw_len, re_enc=0;
char B64digest[50], SHA256digest[35];
char bfKey[512], new_iniKey[KEYBUF_SIZE], old_iniKey[KEYBUF_SIZE], *fptr, *ok_ptr, line_buf[1000], iniPath_new[300];
FILE *h_ini, *h_ini_new;
if (!unsetiniFlag) {
pw_len=strlen(iniPW);
if (pw_len < 1 || (size_t)pw_len > sizeof(new_iniKey)) {
printtext(server, item!=NULL ? window_item_get_target(item) : NULL, MSGLEVEL_CRAP,
"\002FiSH:\002 No parameters. Usage: /setinipw <sekure_blow.ini_password>");
return;
}
if (strfcpy(new_iniKey, (char *)iniPW, sizeof(new_iniKey))==NULL) return;
ZeroMemory(iniPW, pw_len);
pw_len=strlen(new_iniKey);
if (pw_len < 8) {
printtext(server, item!=NULL ? window_item_get_target(item) : NULL, MSGLEVEL_CRAP,
"\002FiSH:\002 Password too short, at least 8 characters needed! Usage: /setinipw <sekure_blow.ini_password>");
return;
}
SHA256_memory(new_iniKey, pw_len, SHA256digest);
ZeroMemory(new_iniKey, sizeof(new_iniKey));
for (i=0; i<40872; i++) SHA256_memory(SHA256digest, 32, SHA256digest);
htob64(SHA256digest, B64digest, 32);
}
strcpy(old_iniKey, iniKey);
if (unsetiniFlag) strcpy(iniKey, default_iniKey); // unsetinipw -> use default blow.ini key
else strcpy(iniKey, B64digest); // this is used for encrypting blow.ini
for (i=0; i<30752; i++) SHA256_memory(SHA256digest, 32, SHA256digest);
htob64(SHA256digest, B64digest, 32); // this is used to verify the entered password
ZeroMemory(SHA256digest, sizeof(SHA256digest));
// re-encrypt blow.ini with new password
strcpy(iniPath_new, iniPath);
strcat(iniPath_new, "_new");
h_ini_new=fopen(iniPath_new, "w");
h_ini=fopen(iniPath,"r");
if (h_ini && h_ini_new) {
while (!feof(h_ini)) {
fptr=fgets(line_buf, sizeof(line_buf)-2, h_ini);
if (fptr) {
ok_ptr=strstr(line_buf, "+OK ");
if (ok_ptr) {
re_enc=1;
strtok(ok_ptr+4, " \n\r");
decrypt_string(old_iniKey, ok_ptr+4, bfKey, strlen(ok_ptr+4));
ZeroMemory(ok_ptr+4, strlen(ok_ptr+4)+1);
encrypt_string(iniKey, bfKey, ok_ptr+4, strlen(bfKey));
strcat(line_buf, "\n");
}
if (fprintf(h_ini_new, "%s", line_buf) < 0) {
ZeroMemory(B64digest, sizeof(B64digest));
ZeroMemory(bfKey, sizeof(bfKey));
ZeroMemory(line_buf, sizeof(line_buf));
ZeroMemory(old_iniKey, sizeof(old_iniKey));
fclose(h_ini);
fclose(h_ini_new);
remove(iniPath_new);
printtext(server, item!=NULL ? window_item_get_target(item) : NULL, MSGLEVEL_CRAP,
"\002FiSH ERROR:\002 Unable to write new blow.ini, probably out of disc space.");
return;
}
}
}
ZeroMemory(bfKey, sizeof(bfKey));
ZeroMemory(line_buf, sizeof(line_buf));
ZeroMemory(old_iniKey, sizeof(old_iniKey));
fclose(h_ini);
fclose(h_ini_new);
remove(iniPath);
rename(iniPath_new, iniPath);
} else return;
if (WritePrivateProfileString("FiSH", "ini_password_Hash", B64digest, iniPath) == -1) {
ZeroMemory(B64digest, sizeof(B64digest));
printtext(server, item!=NULL ? window_item_get_target(item) : NULL, MSGLEVEL_CRAP,
"\002FiSH ERROR:\002 Unable to write to blow.ini, probably out of space or permission denied.");
return;
}
ZeroMemory(B64digest, sizeof(B64digest));
if (re_enc) printtext(server, item!=NULL ? window_item_get_target(item) : NULL,
MSGLEVEL_CRAP, "\002FiSH: Re-encrypted blow.ini\002 with new password.");
if (!unsetiniFlag) printtext(server, item!=NULL ? window_item_get_target(item) : NULL,
MSGLEVEL_CRAP, "\002FiSH:\002 blow.ini password hash saved.");
}
/*
* register SAM/QFS on the host being called with CNS.
* The key value string must contain:
* sun_login
* sun_password (passed as arg cl_pwd)
* name
* email
* asset_prefix = "sam-qfs"
*
* The key value string may contain:
* prxy_enabled
* prxy_port
* prxy_host
* prxy_auth
* prxy_user
* prxy_passwd(passed as arg proxy_pwd)
*
* The cl_pwd byte array must contain the client password for
* the sun account encrypted with the public key returned from
* cns_get_public_key.
*
* If proxy_auth is set to true, the proxy_pwd must be
* the encrypted proxy password, using the same key as above.
*/
int
cns_register(
ctx_t *ctx, /* ARGSUSED */
char *kv_string,
crypt_str_t *cl_pwd,
crypt_str_t *proxy_pwd,
char *clnt_pub_key_hex) {
char *cl_clear = NULL;
unsigned char *secret = NULL;
int secret_len;
cl_reg_cfg_t cl;
sf_prod_info_t *sf;
char asset_dir[MAXPATHLEN];
int retval;
Trace(TR_MISC, "csn registration entry");
/* check the mandatory parameters */
if (ISNULL(kv_string, cl_pwd, clnt_pub_key_hex)) {
Trace(TR_ERR, "cns registration failed %d %s", samerrno,
samerrmsg);
return (-1);
}
memset(&cl, 0, sizeof (cl_reg_cfg_t));
if (cl_pwd->str == NULL) {
samerrno = SE_NULL_PARAMETER;
snprintf(samerrmsg, MAX_MSG_LEN, GetCustMsg(samerrno),
"password");
Trace(TR_ERR, "cns registration failed %d %s", samerrno,
samerrmsg);
goto err;
}
if (parse_kv(kv_string, cl_reg_cfg_tokens, &cl) != 0) {
Trace(TR_ERR, "cns registration failed %d %s", samerrno,
samerrmsg);
goto err;
}
/*
* If there was a client registration id free it. Or it will leak.
* Note that reregistration is allowed in order to change the keys
* that are used for signing the telemetry data.
*/
if (cl.reg_id) {
free(cl.reg_id);
cl.reg_id = NULL;
}
/* Complete the last phase of key agreement */
secret_len = get_secret(clnt_pub_key_hex, &secret);
if (secret_len <= 0) {
set_registration_error(-1);
Trace(TR_ERR, "cns registration failed:getsecret");
goto err;
}
/* get the password clear text */
if (decrypt_string(&cl_clear, secret, cl_pwd->str,
cl_pwd->str_len) != 0) {
set_registration_error(-1);
Trace(TR_ERR, "cns reg failed:bad clear cl pass");
goto err;
}
/* add the proxy password to the cl struct */
if (proxy_pwd != NULL) {
/*
* proxy password should be populated if it is
* present even if proxy authentication is not enabled.
* This behavior is really more forward looking for
* when telemetry is enabled.
*/
if (decrypt_string(&(cl.prxy.passwd), secret, proxy_pwd->str,
proxy_pwd->str_len) != 0) {
set_registration_error(-1);
Trace(TR_ERR, "cns reg failed:bad clear prxy pass");
goto err;
}
}
/* check the rest of the parameters */
if (check_cl_reg_cfg(&cl, B_TRUE) != 0) {
setsamerr(SE_INVALID_REG_PARAMS);
Trace(TR_ERR, "cns registration failed %d %s", samerrno,
samerrmsg);
goto err;
}
/* create the data directory for this asset */
if (cl.asset_prefix == NULL) {
set_registration_error(-1);
Trace(TR_ERR, "cns registration failed: %d %s",
samerrno, samerrmsg);
goto err;
}
snprintf(asset_dir, sizeof (upath_t), CNS_ASSETDIR_SPEC,
cl.asset_prefix);
if (create_dir(ctx, asset_dir) != 0) {
Trace(TR_ERR, "cns registration failed: %d %s",
samerrno, samerrmsg);
goto err;
}
/*
* generate the public and private keys for this client-asset pair
*/
if ((retval = regstr_generate_public_private_key(cl.asset_prefix))
!= 0) {
set_registration_error(retval);
Trace(TR_ERR, "cns registration failed: %d %s",
samerrno, samerrmsg);
goto err;
}
strlcat(asset_dir, CNS_CLIENT_CONF, sizeof (upath_t));
if (get_samfs_type(ctx) == SAMQFS) {
sf = &samqfs_swordfish_data;
} else {
sf = &qfs_swordfish_data;
}
/*
* This could save the client data now so that it can be
* fetched even if the registration fails. The user would still
* need to enter the appropriate passwords but nothing else would
* be required. The reason it is done later is that the reg_id needs
* to be saved and is not yet available.
*/
if ((retval = regstr_postclient_regis_data(&cl,
(char *)cl_clear)) != 0) {
set_registration_error(retval);
Trace(TR_ERR, "cns registration failed: %d %s",
samerrno, samerrmsg);
goto err;
}
/*
* Only post the product registration once. The reason to
* post the client registration more than once is that is how
* the key pair gets changed
*/
if (!is_registered(&cl)) {
char *addn_info;
/*
* If we can get additional version information about the
* packages include it but ignore errors.
*/
if (get_associated_package_info(&addn_info) == 0) {
sf->additional_info = addn_info;
}
if ((retval = regstr_postproduct_regis_data(sf, &cl)) != 0) {
set_registration_error(retval);
Trace(TR_ERR, "cns registration failed: %d %s",
samerrno, samerrmsg);
goto err;
}
cl.registered = B_TRUE;
if (sf->additional_info) {
free(sf->additional_info);
sf->additional_info = NULL;
}
}
if (save_client_conf(asset_dir, &cl) != 0) {
Trace(TR_ERR, "cns registration failed: %d %s",
samerrno, samerrmsg);
goto err;
}
free_sensitive_buf((char **)&secret, secret_len);
free_sensitive_buf(&(cl_clear), strlen(cl_clear));
if (cl.prxy.passwd) {
free_sensitive_buf(&(cl.prxy.passwd), strlen(cl.prxy.passwd));
}
free_cl_reg_cfg_fields(&cl);
Trace(TR_MISC, "cns registration succeeded");
return (0);
err:
if (sf->additional_info) {
free(sf->additional_info);
sf->additional_info = NULL;
}
free_sensitive_buf((char **)&secret, secret_len);
free_sensitive_buf(&(cl_clear), strlen(cl_clear));
if (cl.prxy.passwd) {
free_sensitive_buf(&(cl.prxy.passwd), strlen(cl.prxy.passwd));
}
free_cl_reg_cfg_fields(&cl);
return (-1);
}
u8 *cmd_save_game(u8 *c)
{
u8 newline_orig;
FILE *save_stream; // file handle
u8 *msg;
clock_state = 1;
newline_orig = msgstate.newline_char;
msgstate.newline_char = '@';
decrypt_string(inv_obj_string, inv_obj_string+inv_obj_string_size);
if (save_dir == 0)
save_dir = vstring_new(0, 200);
if (save_filename == 0)
save_filename = vstring_new(0, 250);
if ( state_get_info('s') != 0)// select the game
{
if (strlen(save_filename->data) > strlen(save_dir->data))
msg = alloca(200 + strlen(save_filename->data));
else
msg = alloca(200 + strlen(save_dir->data));
if (state_name_auto[0] == 0)
{
sprintf(msg, "About to save the game\ndescribed as:\n\n%s\n\nin file:\n %s\n\n%s",
save_description, save_filename->data,
"Press ENTER to continue.\nPress ESC to cancel.");
message_box_draw(msg, 0, 0x23, 0);
if ( user_bolean_poll() == 0)
goto save_end;
}
dir_preset_change(DIR_PRESET_GAME);
save_stream = fopen(save_filename->data, "wb");
if ( save_stream == 0)
{
sprintf(msg, "The directory\n %s\n is full or the disk is write-protected.\nPress ENTER to continue."
, save_dir->data);
message_box(msg);
}
else
{
if (fwrite(save_description, sizeof(u8), 0x1f, save_stream) != 0x1f)
goto save_err;
if (state_write(save_stream, &state, sizeof(AGI_STATE)) == 0)
goto save_err;
if (state_write(save_stream, objtable, objtable_size) == 0)
goto save_err;
if (state_write(save_stream, inv_obj_table, inv_obj_table_size*sizeof(INV_OBJ)) == 0)
goto save_err;
if (state_write(save_stream, inv_obj_string, inv_obj_string_size) == 0)
goto save_err;
if (state_write(save_stream, script_head, state.script_size<<1) == 0)
goto save_err;
if (state_write(save_stream, (void *)scan_start_list, logic_save_scan_start()) != 0)
goto save_close;
save_err:
fclose(save_stream);
remove(save_filename->data);
message_box("The disk is full.\nPress ENTER to continue.");
goto save_end;
save_close:
fclose(save_stream);
}
}
save_end:
cmd_close_window(0);
msgstate.newline_char = newline_orig;
clock_state = 0;
decrypt_string(inv_obj_string, inv_obj_string+inv_obj_string_size);
return c;
}
static void wire_filter(char *from, char *cmd, char *param)
{
char wirecrypt[512];
char wirewho[512];
char wiretmp2[512];
char wiretmp[512];
char wirereq[512];
wire_list *w = wirelist;
char reqsock;
time_t now2 = now;
char idle[20];
char *enctmp;
strcpy(wirecrypt, &cmd[5]);
strcpy(wiretmp, param);
nsplit(wirereq, param);
/*
* !wire<crypt"wire"> !wirereq <destbotsock> <crypt"destbotnick">
* ----- wirecrypt wirereq wirewho param
*/
if (!strcmp(wirereq, "!wirereq")) {
nsplit(wirewho, param);
while (w) {
if (!strcmp(w->crypt, wirecrypt)) {
int idx = findanyidx(w->sock);
reqsock = atoi(wirewho);
if (now2 - dcc[idx].timeval > 300) {
unsigned long Days, hrs, mins;
Days = (now2 - dcc[idx].timeval) / 86400;
hrs = ((now2 - dcc[idx].timeval) - (Days * 86400)) / 3600;
mins = ((now2 - dcc[idx].timeval) - (hrs * 3600)) / 60;
if (Days > 0)
sprintf(idle, " [%s %lud%luh]", WIRE_IDLE, Days, hrs);
else if (hrs > 0)
sprintf(idle, " [%s %luh%lum]", WIRE_IDLE, hrs, mins);
else
sprintf(idle, " [%s %lum]", WIRE_IDLE, mins);
} else
idle[0] = 0;
sprintf(wirereq, "----- %c%-9s %-9s %s%s",
geticon(idx), dcc[idx].nick, botnetnick, dcc[idx].host, idle);
enctmp = encrypt_string(w->key, wirereq);
strcpy(wiretmp, enctmp);
nfree(enctmp);
sprintf(wirereq, "zapf %s %s !wire%s !wireresp %s %s %s",
botnetnick, from, wirecrypt, wirewho, param, wiretmp);
dprintf(nextbot(from), "%s\n", wirereq);
if (dcc[idx].u.chat->away) {
sprintf(wirereq, "----- %s: %s\n", WIRE_AWAY,
dcc[idx].u.chat->away);
enctmp = encrypt_string(w->key, wirereq);
strcpy(wiretmp, enctmp);
nfree(enctmp);
sprintf(wirereq, "zapf %s %s !wire%s !wireresp %s %s %s",
botnetnick, from, wirecrypt, wirewho, param, wiretmp);
dprintf(nextbot(from), "%s\n", wirereq);
}
}
w = w->next;
}
return;
}
if (!strcmp(wirereq, "!wireresp")) {
nsplit(wirewho, param);
reqsock = atoi(wirewho);
w = wirelist;
nsplit(wiretmp2, param);
while (w) {
if (w->sock == reqsock) {
int idx = findanyidx(reqsock);
enctmp = decrypt_string(w->key, wiretmp2);
strcpy(wirewho, enctmp);
nfree(enctmp);
if (!strcmp(dcc[idx].nick, wirewho)) {
enctmp = decrypt_string(w->key, param);
dprintf(idx, "%s\n", enctmp);
nfree(enctmp);
return;
}
}
w = w->next;
}
return;
}
while (w) {
if (!strcmp(wirecrypt, w->crypt))
wire_display(findanyidx(w->sock), w->key, wirereq, param);
w = w->next;
}
}
