void UTIL_FindServerClassPrint(const char *name_cmd)
{
bool bInterfaceErr = false;
char temp[128];
char name[128];
strncpy(name,name_cmd,127);
name[127] = 0;
strlow(name);
try
{
ServerClass *pClass = servergamedll->GetAllServerClasses();
while (pClass)
{
strncpy(temp,pClass->m_pNetworkName,127);
temp[127] = 0;
strlow(temp);
if (strstr(temp,name) != NULL )
{
CBotGlobals::botMessage(NULL,0,"%s",pClass->m_pNetworkName);
//break;
}
pClass = pClass->m_pNext;
}
}
catch (...)
{
bInterfaceErr = true;
}
#ifndef __linux__
if ( bInterfaceErr )
{
// IServerGameDLL_004 == IServerGameDLL except without the replay init function
ServerClass *pClass = ((IServerGameDLL_004*)servergamedll)->GetAllServerClasses();
while (pClass)
{
strncpy(temp,pClass->m_pNetworkName,127);
temp[127] = 0;
strlow(temp);
if (strstr(temp,name) != NULL )
{
CBotGlobals::botMessage(NULL,0,"%s",pClass->m_pNetworkName);
//break;
}
pClass = pClass->m_pNext;
}
}
#endif
}
hash_stat hash_plugin_parse_hash(char *hashline, char *filename)
{
char username[HASHFILE_MAX_LINE_LENGTH];
char hash[HASHFILE_MAX_LINE_LENGTH];
char salt[HASHFILE_MAX_LINE_LENGTH];
char line[HASHFILE_MAX_LINE_LENGTH];
char line2[HASHFILE_MAX_LINE_LENGTH];
char *temp_str;
if (!hashline) return hash_err;
if (strlen(hashline)<2) return hash_err;
snprintf(line, HASHFILE_MAX_LINE_LENGTH-1, "%s", hashline);
strcpy(username, strtok(line, ":"));
temp_str=strtok(NULL,":");
if (temp_str)
{
strcpy(hash, temp_str);
}
/* Hash is not 32 characters long => not a md5 hash */
if ((strlen(hash)!=32)&&(strlen(username)!=32))
{
return hash_err;
}
/* No hash provided at all */
if (strcmp(username,hashline)==0)
{
return hash_err;
}
/* salt */
temp_str=strtok(NULL,":");
if (temp_str)
{
if (strlen(salt)>32) return hash_err;
strcpy(salt, temp_str);
}
else
{
strcpy(salt,hash);
strcpy(hash,username);
strcpy(username,"N/A");
}
strlow(hash);
hex2str(line2, hash, 32);
(void)hash_add_username(username);
(void)hash_add_hash(line2, 16);
(void)hash_add_salt(salt);
(void)hash_add_salt2("");
return hash_ok;
}
hash_stat hash_plugin_parse_hash(char *hashline, char *filename)
{
char username[256];
char *hash = alloca(256);
//char line[HASHFILE_MAX_LINE_LENGTH];
char line[256];
char *line2 = alloca(256);
char *temp_str;
int len;
if (!hashline) return hash_err;
if (strlen(hashline)>256) return hash_err;
if (strlen(hashline)<2) return hash_err;
snprintf(line, HASHFILE_MAX_LINE_LENGTH-1, "%s", hashline);
strcpy(username, strtok(line, ":"));
temp_str = strtok(NULL,":");
if (!temp_str)
{
temp_str = alloca(256);
strcpy(temp_str,username);
strcpy(username,"N/A");
}
len = strlen(temp_str);
/* Bad constant header */
if (!strstr(temp_str,"0x0200"))
{
return hash_err;
}
/* Bad hash */
if (strlen(temp_str)!=142)
{
return hash_err;
}
(void)hash_add_username(username);
strcpy(line2,strlow(temp_str));
/* Skip header, add salt, skip case-sensitive hash, get uppercase one */
strcpy(line, line2+14);
line[128] = 0;
hex2str(hash, line, 128);
(void)hash_add_hash((char *)hash, 64);
strncpy(line, line2+6, 8);
line[8]=0;
(void)hash_add_salt(line);
(void)hash_add_salt2("");
return hash_ok;
}
/*
* The check_lines function will take in 5 inputs, check the provided file, and print any lines matched.
*
* Parameters:
* file | the file to be read
* checkCaps | whether or not to factor in upper or lower case while checking
* printLines | whether or not to print the line numbers
* word | the provided string to match for
* filename | the name of the given file
*
* Return:
* void
*/
void check_lines(FILE *file, int checkCaps, int printLines,
char *word, char *filename) {
if (checkCaps == 1) {
word = strlow(word);
}
char line[MAX_LINE_LENGTH];
char line_copy[MAX_LINE_LENGTH];
int count = 1;
while (fgets(line, MAX_LINE_LENGTH, file)) {
if (checkCaps == 1) {
strncpy(line_copy, line, MAX_LINE_LENGTH);
strlow(line);
}
if (strstr(line, word)) {
printf("%s: ", filename);
if (printLines == 1) {
printf("line %d: ", count);
}
printf("%s", checkCaps == 1 ? line_copy : line);
}
count++;
}
}
static void set_devno(char *optarg)
{
size_t size;
size = strlen(optarg);
if (size == 4) {
/*
* the file below /sys expects the
* eight digit notation
*/
strncat(devno, "0.0.", 4);
strncat(devno, optarg, 4);
strlow(devno);
} else if (size == 8) {
strncpy(devno, optarg, sizeof(devno));
strlow(devno);
devno[8] = '\0';
} else {
fprintf(stderr, "%s: Invalid device number specified\n", name);
exit(1);
}
devno_set = 1;
}
hash_stat hash_plugin_parse_hash(char *hashline, char *filename)
{
char username[HASHFILE_MAX_LINE_LENGTH];
char hash[HASHFILE_MAX_LINE_LENGTH];
char line[HASHFILE_MAX_LINE_LENGTH];
char *temp_str;
char line2[HASHFILE_MAX_LINE_LENGTH];
if (!hashline) return hash_err;
if (strlen(hashline)<2) return hash_err;
snprintf(line, HASHFILE_MAX_LINE_LENGTH-1, "%s", hashline);
bzero(username,20);
strcpy(username, strtok(line, ":"));
temp_str=strtok(NULL,":");
if (temp_str)
{
if (temp_str[0]=='$') strcpy(hash, temp_str+1); // Strip $
else strcpy(hash, temp_str);
}
/* Hash is not 40 characters long => not a smf hash */
if (strlen(hash)!=40)
{
return hash_err;
}
/* No hash provided at all */
if (strcmp(username,hashline)==0)
{
return hash_err;
}
strlow(hash);
hex2str(line2, hash, 40);
(void)hash_add_username(username);
(void)hash_add_hash(line2, 20);
(void)hash_add_salt(" ");
(void)hash_add_salt2("");
return hash_ok;
}
char *ft_strcapitalize(char *str)
{
int i;
i = 0;
strlow(str);
if (is_lowercase(str[0]))
str[0] -= ('a' - 'A');
i = 1;
while (str[i])
{
if (!is_number(str[i - 1]) && !is_upercase(str[i - 1]) &&
!is_lowercase(str[i - 1]))
if (is_lowercase(str[i]))
str[i] -= 'a' - 'A';
i++;
}
return (str);
}
hash_stat hash_plugin_parse_hash(char *hashline, char *filename)
{
char username[HASHFILE_MAX_LINE_LENGTH];
char hash[HASHFILE_MAX_LINE_LENGTH];
char line[HASHFILE_MAX_LINE_LENGTH];
char line2[HASHFILE_MAX_LINE_LENGTH];
char *temp_str;
if (!hashline) return hash_err;
if (strlen(hashline)<2) return hash_err;
snprintf(line, HASHFILE_MAX_LINE_LENGTH-1, "%s", hashline);
strcpy(username, strtok(line, ":"));
temp_str=strtok(NULL,":");
if (temp_str)
{
strcpy(hash, temp_str);
}
else return hash_err;
/* Hash is not 32 characters long => not a mscash2 hash */
if ((strlen(hash)!=32))
{
return hash_err;
}
strlow(hash);
hex2str(line2, hash, 32);
(void)hash_add_username(username);
(void)hash_add_hash(line2, 16);
(void)hash_add_salt(" ");
(void)hash_add_salt2("");
return hash_ok;
}
/* Milen: Do the parsing inside the plugin instead */
static hash_stat load_pdf(char *filename)
{
int fd;
int a,flag;
char *buf;
char *match=NULL;
size_t size;
int ver,rel;
char *trailer;
char *encdict;
char *end;
int trailersize;
int encdictsize;
char *tok;
char *tok1;
char *object1;
char *object;
char finalobject[1024];
char id[255];
char ostr[255],ustr[255];
int v,r,length,p,meta;
size_t hashsize,usize,osize;
osize=usize=0;
fd = open(filename,O_RDONLY);
size = lseek(fd,0,SEEK_END);
lseek(fd,0,SEEK_SET);
buf = malloc(size);
read(fd,buf,size);
close(fd);
match = memmem(buf,size,"PDF-",4);
if (!match) goto out;
ver=atoi(match+4);
rel=atoi(match+6);
trailer = memmem(buf,size,"trailer",strlen("trailer"));
if (!trailer)
{
trailer = memmem(buf,size,"DecodeParms",strlen("DecodeParms"));
if (!trailer) goto out;
trailer+=strlen("DecodeParms");
end = memmem(trailer,size-(trailer-buf),"stream",strlen("stream"));
if (!end) goto out;
trailersize = end-trailer;
}
else
{
trailer+=strlen("trailer");
end = memmem(trailer,size-(trailer-buf),">>",strlen(">>"));
if (!end) goto out;
trailersize = end-trailer;
}
object = memmem(trailer,trailersize,"Encrypt ",strlen("Encrypt "));
if (!object) goto out;
object+=strlen("Encrypt ");
object1 = malloc(trailersize);
memcpy(object1,object,16);
tok = strtok(object1," ");
tok1 = strtok(NULL," ");
sprintf(finalobject,"%s %s obj",tok,tok1);
free(object1);
encdict = memmem(buf,size,finalobject,strlen(finalobject));
if (!encdict) goto out;
encdict+=strlen(finalobject);
end = memmem(encdict,size-(encdict-buf),"endobj",strlen("endobj"));
if (!end) goto out;
encdictsize = end-encdict;
tok = memmem(encdict,encdictsize,"/V ",strlen("/V "));
if (!tok) goto out;
tok+=strlen("/V ");
v=atoi(tok);
tok = memmem(encdict,encdictsize,"/R ",strlen("/R "));
if (!tok) goto out;
tok+=strlen("/R ");
r=atoi(tok);
length=0;
tok = memmem(encdict,encdictsize,"/Length ",strlen("/Length "));
if (!tok) goto out;
tok+=strlen("/Length ");
length=atoi(tok);
while (tok)
{
tok = memmem(tok,encdictsize-(tok-encdict),"/Length ",strlen("/Length "));
if (tok)
{
tok+=strlen("/Length ");
a=atoi(tok);
if (a>length) length = a;
}
}
tok = memmem(encdict,encdictsize,"/P ",strlen("/P "));
if (!tok) goto out;
tok+=strlen("/P ");
p=atoi(tok);
tok = memmem(encdict,encdictsize,"/EncryptMetadata",strlen("/EncryptMetadata"));
meta=1;
if (!tok) meta=1;
else
{
tok+=strlen("/EncryptMetadata");
if ((tok[0]==' ')||(tok[0]=='\r')||(tok[0]=='\n')||(tok[0]=='\t'))
{
if (memcmp(tok+1,"false",strlen("false"))==0) meta=0;
else meta=1;
}
}
tok = memmem(trailer,trailersize,"/ID",strlen("/ID"));
if (!tok) goto out;
tok = memmem(tok,trailersize,"<",strlen("<"));
if (!tok) goto out;
tok+=strlen("<");
tok1 = memmem(tok,trailersize - (tok-trailer),">",1);
if (!tok1) goto out;
hashsize=tok1-tok;
bzero(id,255);
if (hashsize>255) hashsize=255;
memcpy(id,tok,hashsize);
if ((ver==1)&&(rel==7))
{
// Search for 'U' in letters
tok = memmem(encdict,encdictsize,"/U(",strlen("/U("));
if (!tok) goto out;
tok+=strlen("/U(");
a=0;flag=0;usize=0;
while (flag==0)
{
if (tok[a]=='\\')
{
a++;
switch (tok[a])
{
case 'n' : ustr[usize]='\n';break;
case 'r' : ustr[usize]='\r';break;
case 't' : ustr[usize]='\t';break;
case 'v' : ustr[usize]='\v';break;
case 'f' : ustr[usize]='\f';break;
case 'b' : ustr[usize]='\b';break;
case 'a' : ustr[usize]='\a';break;
case ')' : ustr[usize]=')';break;
case '(' : ustr[usize]='(';break;
case '\\' : ustr[usize]='\\';break;
case '0' : ustr[usize]=0;break;
}
usize++;
a++;
}
else if ((tok[a]==')')&&(tok[a-1]!='\\')) flag=1;
else
{
ustr[usize]=tok[a];
a++;
usize++;
}
if (usize==255) flag=1;
}
// Search for 'O' in letters
tok = memmem(encdict,encdictsize,"/O(",strlen("/O("));
if (!tok) goto out;
tok+=strlen("/O(");
a=0;flag=0;osize=0;
while (flag==0)
{
if (tok[a]=='\\')
{
a++;
switch (tok[a])
{
case 'n' : ostr[osize]='\n';break;
case 'r' : ostr[osize]='\r';break;
case 't' : ostr[osize]='\t';break;
case 'v' : ostr[osize]='\v';break;
case 'f' : ostr[osize]='\f';break;
case 'b' : ostr[osize]='\b';break;
case 'a' : ostr[osize]='\a';break;
case ')' : ostr[osize]=')';break;
case '(' : ostr[osize]='(';break;
case '\\' : ostr[osize]='\\';break;
case '0' : ostr[osize]=0;break;
}
osize++;
a++;
}
else if ((tok[a]==')')&&(tok[a-1]!='\\')) flag=1;
else
{
ostr[osize]=tok[a];
a++;
osize++;
}
if (osize==255) flag=1;
}
}
else
{
// Search for 'U' in letters
tok = memmem(encdict,encdictsize,"/U(",strlen("/U("));
if (!tok) goto out;
tok+=strlen("/U(");
a=0;flag=0;usize=0;
while (flag==0)
{
if (tok[a]=='\\')
{
a++;
switch (tok[a])
{
case 'n' : ustr[usize]='\n';break;
case 'r' : ustr[usize]='\r';break;
case 't' : ustr[usize]='\t';break;
case 'v' : ustr[usize]='\v';break;
case 'f' : ustr[usize]='\f';break;
case 'b' : ustr[usize]='\b';break;
case 'a' : ustr[usize]='\a';break;
case ')' : ustr[usize]=')';break;
case '(' : ustr[usize]='(';break;
case '\\' : ustr[usize]='\\';break;
case '0' : ustr[usize]=0;break;
}
usize++;
a++;
}
else if ((tok[a]==')')&&(tok[a-1]!='\\')) flag=1;
else
{
ustr[usize]=tok[a];
a++;
usize++;
}
if (usize==255) flag=1;
}
// Search for 'O' in letters
tok = memmem(encdict,encdictsize,"/O(",strlen("/O("));
if (!tok) goto out;
tok+=strlen("/O(");
a=0;flag=0;osize=0;
while (flag==0)
{
if (tok[a]=='\\')
{
a++;
switch (tok[a])
{
case 'n' : ostr[osize]='\n';break;
case 'r' : ostr[osize]='\r';break;
case 't' : ostr[osize]='\t';break;
case 'v' : ostr[osize]='\v';break;
case 'f' : ostr[osize]='\f';break;
case 'b' : ostr[osize]='\b';break;
case 'a' : ostr[osize]='\a';break;
case ')' : ostr[osize]=')';break;
case '(' : ostr[osize]='(';break;
case '\\' : ostr[osize]='\\';break;
case '0' : ostr[osize]=0;break;
}
osize++;
a++;
}
else if ((tok[a]==')')&&(tok[a-1]!='\\')) flag=1;
else
{
ostr[osize]=tok[a];
a++;
osize++;
}
if (osize==255) flag=1;
}
}
cs.V=v;
cs.R=r;
cs.length = length;
cs.P = p;
cs.encrypt_metadata = meta;
cs.length_id = hashsize/2;
hex2str((char *) cs.id, strlow(id), cs.length_id * 2);
cs.length_u = usize;
memcpy(cs.u,ustr,usize);
cs.length_o = osize;
memcpy(cs.o,ostr,osize);
free(buf);
return hash_ok;
out:
free(buf);
return hash_err;
}
hash_stat hash_plugin_parse_hash(char *hashline, char *filename)
{
char username[HASHFILE_MAX_LINE_LENGTH];
char hash[HASHFILE_MAX_LINE_LENGTH];
char salt[HASHFILE_MAX_LINE_LENGTH];
char line[HASHFILE_MAX_LINE_LENGTH];
char line2[HASHFILE_MAX_LINE_LENGTH];
char *temp_str;
if (!hashline) return hash_err;
if (strlen(hashline)<2) return hash_err;
snprintf(line, HASHFILE_MAX_LINE_LENGTH-1, "%s", hashline);
strcpy(salt,"");
strcpy(username, strtok(line, ":"));
/* OK, that is an username */
if (strlen(username)>1)
{
temp_str=strtok(NULL,":");
if (temp_str)
{
/* type A */
if (temp_str[0]=='A')
{
temp_str=strtok(NULL,":");
if (temp_str) strcpy(hash, temp_str);
else return hash_err;
}
else if (temp_str[0]=='B')
{
temp_str=strtok(NULL,":");
if (temp_str)
{
strcpy(salt, temp_str);
temp_str=strtok(NULL,":");
if (temp_str) strcpy(hash, temp_str);
}
}
}
else return hash_err;
}
/* Nope, not an username */
else
{
/* type A */
if (username[0]=='A')
{
temp_str=strtok(NULL,":");
if (temp_str) strcpy(hash, temp_str);
else return hash_err;
}
else if (username[0]=='B')
{
temp_str=strtok(NULL,":");
if (temp_str)
{
strcpy(salt, temp_str);
temp_str=strtok(NULL,":");
if (temp_str) strcpy(hash, temp_str);
}
}
else return hash_err;
strcpy(username,"N/A");
}
/* Hash is not 32 characters long => not a md5 hash */
if ((strlen(hash)!=32)&&(strlen(username)!=32))
{
return hash_err;
}
strlow(hash);
hex2str(line2, hash, 32);
(void)hash_add_username(username);
(void)hash_add_hash(line2, 16);
(void)hash_add_salt(salt);
(void)hash_add_salt2("");
return hash_ok;
}
hash_stat hash_plugin_parse_hash(char *hashline, char *filename)
{
char username[HASHFILE_MAX_LINE_LENGTH];
char hash[HASHFILE_MAX_LINE_LENGTH];
char line[HASHFILE_MAX_LINE_LENGTH];
char *temp_str = NULL;
if (!hashline) return hash_err;
if (strlen(hashline)<2) return hash_err;
snprintf(line, HASHFILE_MAX_LINE_LENGTH-1, "%s", hashline);
strcpy(username, strtok(line, ":"));
temp_str=strtok(NULL,":");
if (temp_str)
{
strcpy(hash, temp_str);
/* Hash is not 32 characters long => not a md5 hash */
if (strlen(hash)!=32)
{
return hash_err;
}
/* Salt could be 32 chars long, check if that is the case */
int flag=0;
int a;
for (a=0;a<strlen(hash);a++) if ( ((hash[a]<'0')||(hash[a]>'9'))&&((hash[a]<'a')||(hash[a]>'f'))) flag=1;
if (flag==1) return hash_err;
/* No hash provided at all */
if (strcmp(username,hashline)==0)
{
return hash_err;
}
(void)hash_add_username(username);
strlow(hash);
hex2str(line, hash, 32);
(void)hash_add_hash(line,16);
}
else
{
strcpy(hash, username);
/* Hash is not 32 characters long => not a md5 hash */
if (strlen(hash)!=32)
{
return hash_err;
}
(void)hash_add_username("N/A");
strlow(hash);
hex2str(line, hash, 32);
(void)hash_add_hash(line,16);
}
(void)hash_add_salt("");
(void)hash_add_salt2("");
return hash_ok;
}
