int TlenMUCRecvMessage(const char *from, long timestamp, XmlNode *bodyNode)
{
// if (JabberListExist(LIST_CHATROOM, from)) {
char *localMessage;
char *nick, *style, *roomId, *userId;
int iStyle;
MUCCEVENT mucce;
roomId = JabberLoginFromJID(from);
userId = JabberResourceFromJID(from);
nick = getDisplayName(userId);
localMessage = JabberTextDecode(bodyNode->text);
mucce.cbSize = sizeof(MUCCEVENT);
mucce.iType = MUCC_EVENT_MESSAGE;
mucce.pszID = roomId;
mucce.pszModule = jabberProtoName;
mucce.pszText = localMessage;
mucce.pszUID = userId;//from;
mucce.pszNick = nick;
mucce.time = timestamp;
mucce.bIsMe = isSelf(roomId, userId);
mucce.dwFlags = 0;
mucce.iFontSize = 0;
style = JabberXmlGetAttrValue(bodyNode, "f");
if (style!=NULL) {
iStyle = atoi(style);
if (iStyle & 1) mucce.dwFlags |= MUCC_EF_FONT_BOLD;
if (iStyle & 2) mucce.dwFlags |= MUCC_EF_FONT_ITALIC;
if (iStyle & 4) mucce.dwFlags |= MUCC_EF_FONT_UNDERLINE;
}
style = JabberXmlGetAttrValue(bodyNode, "c");
if (style!=NULL && strlen(style)>5) {
iStyle = (stringToHex(style)<<16) | (stringToHex(style+2)<<8) | stringToHex(style+4);
} else {
iStyle = 0xFFFFFFFF;
}
mucce.color = (COLORREF) iStyle;
style = JabberXmlGetAttrValue(bodyNode, "s");
if (style!=NULL) {
iStyle = atoi(style);
} else {
iStyle = 0;
}
mucce.iFontSize = iStyle;
style = JabberXmlGetAttrValue(bodyNode, "n");
if (style!=NULL) {
iStyle = atoi(style)-1;
} else {
iStyle = 0;
}
mucce.iFont = iStyle;
CallService(MS_MUCC_EVENT, 0, (LPARAM) &mucce);
mir_free(roomId);
mir_free(userId);
mir_free(nick);
mir_free(localMessage);
// }
return 0;
}
static bool mfTransKey()
{
BYTE mima[6], i;
BYTE datasector = 0, slength;
BOOL status;
CString sSend = "FFFFFFFFFFFF", s;
slength = sSend.GetLength();
for (i = 0; i < 6; i++) {
if (sSend == "") {
mima[i] = 0;
}
else {
s = sSend.Left(2);
mima[i] = stringToHex(s);
sSend = sSend.Right(slength-2);
slength = sSend.GetLength();
}
}
status = TransKey(&datasector, mima);
if (!status)
return true;
else
return false;
}
lms_priv_key_t* create_lms_priv_key(void)
{
lms_priv_key_t* lms_private_key = (lms_priv_key_t*) malloc(sizeof(lms_priv_key_t));
unsigned int q = 0;
char temp_string[5] = {0};
entropy_read(lms_private_key->I,ENTROPY_SIZE);
//printf("I: %s\n",stringToHex(lms_private_key->I,ENTROPY_SIZE));
lms_private_key->priv = (list_node_t *) malloc(NUM_LEAF_NODES *sizeof(list_node_t));
lms_private_key->pub = (list_node_t *) malloc(NUM_LEAF_NODES *sizeof(list_node_t));
for(q = 0; q < NUM_LEAF_NODES; q++)
{
//printf("I: %s q: %s \n ",lms_private_key->I,uint32ToString(q,temp_string));
lms_private_key->priv[(unsigned int)q].data = (void *)generate_private_key();
lms_private_key->pub[(unsigned int)q].data = (void *)generate_public_key(
(list_node_t* )lms_private_key->priv[(unsigned int)q].data,\
lms_private_key->I, uint32ToString(q,temp_string));
lms_private_key->priv[(unsigned int)q].next = NULL;
lms_private_key->pub[(unsigned int)q].next = NULL;
D(printf(" Generating %u th OTS key PUBLIC KEY %s \n",q,stringToHex(lms_private_key->pub[(unsigned int)q].data,N));)
//exit(1);
}
lms_private_key->nodes = (list_node_t *) malloc( 2* NUM_LEAF_NODES *sizeof(list_node_t));
for(q = 0; q < 2* NUM_LEAF_NODES; q++)
{
lms_private_key->nodes[(unsigned int)q].data = (char *)malloc(N * sizeof(char));
lms_private_key->nodes[(unsigned int)q].next = NULL;
}
lms_private_key->leaf_num = 0;
lms_private_key->lms_public_key = T(lms_private_key,1);
return lms_private_key;
}
unsigned int lms_verify_signature(char* sig, char* public_key, char* message, unsigned int mes_len)
{
lms_sig_t lms_signature;
lm_ots_sig_t decoded_sig;
unsigned int node_num = 0;
list_node_t* temp_node = NULL;
char temp_input[N + ENTROPY_SIZE + 4 + 1] = {0};
char temp_string[5] = {0};
char temp[N + N + ENTROPY_SIZE + 4 + 1] = {0};
char* lm_ots_sig = NULL;
decode_lms_sig(sig, &lms_signature);
temp_node = lms_signature.path;
decode_lmots_sig(lms_signature.lm_ots_sig,&decoded_sig);// note: only q is actually needed here
node_num = stringToUint((unsigned char*)decoded_sig.q,4) + NUM_LEAF_NODES;
lm_ots_sig = lmots_sig_to_public_key(lms_signature.lm_ots_sig, message,mes_len);
memcpy(temp_input,lm_ots_sig,N*sizeof(char));
memcpy(temp_input + N,decoded_sig.I,ENTROPY_SIZE*sizeof(char));
memcpy(temp_input + (N + ENTROPY_SIZE),uint32ToString(node_num,temp_string),4*sizeof(char));
memcpy(temp_input + (N + ENTROPY_SIZE + 4)*sizeof(char),uint8ToString(D_LEAF,temp_string),1);
H(temp_input,temp_input,N + ENTROPY_SIZE + 4 + 1);
memcpy(temp,temp_input,N);
while(node_num > 1)
{
//printf("S(%d):\t %s \n ",node_num, stringToHex(temp_input,N));
//printf("temp_node %p \n ",temp_node);
//printf("data %s %d \n ",stringToHex(temp_node->data,N),node_num);
if (node_num % 2)
{
//print "adding node " + str(node_num - 1)
memcpy(temp,temp_node->data,N*sizeof(char));
memcpy(temp + N ,temp_input,N*sizeof(char));
memcpy(temp + N + N,decoded_sig.I,ENTROPY_SIZE*sizeof(char));
memcpy(temp + N + N + ENTROPY_SIZE,uint32ToString(node_num/2,temp_string),4*sizeof(char));
memcpy(temp + N + N + ENTROPY_SIZE + 4 ,uint8ToString(D_INTR,temp_string),1);
//printf("INPUT: %s \n ",stringToHex(temp, 2*N +36));
H(temp,temp_input, N + N + ENTROPY_SIZE + 4 + 1);
}
else
{
// print "adding node " + str(node_num + 1)
memcpy(temp + N ,temp_node->data,N*sizeof(char));
memcpy(temp + N + N,decoded_sig.I,ENTROPY_SIZE*sizeof(char));
memcpy(temp + N + N + ENTROPY_SIZE,uint32ToString(node_num/2,temp_string),4*sizeof(char));
memcpy(temp + N + N + ENTROPY_SIZE + 4,uint8ToString(D_INTR,temp_string),1);
//printf("INPUT: %s \n ",stringToHex(temp, 2*N +36));
H(temp,temp_input, N + N + ENTROPY_SIZE + 4 + 1);
}
memcpy(temp,temp_input,N);
node_num = node_num/2;
temp_node = temp_node->next;
}
/* Clean up the allocated data */
free(lm_ots_sig);
free(lms_signature.lm_ots_sig);
cleanup_link_list(lms_signature.path);
cleanup_link_list(decoded_sig.y);
D(printf("GEN PUB: %s \n",stringToHex(temp,N));)
void ofxFlashXFLBuilder :: setupStrokeForShape ( ofxFlashShape* shape )
{
if( tagExists( "stroke", 0 ) )
{
pushTag( "stroke", 0 );
int solidStrokeWeight;
solidStrokeWeight = getAttribute( "SolidStroke", "weight", 0, 0 );
pushTag( "SolidStroke", 0 );
pushTag( "fill", 0 );
string fillSolidColor;
fillSolidColor = getAttribute( "SolidColor", "color", "#000000", 0 );
fillSolidColor = cleanHexString( fillSolidColor );
float fillAlpha;
fillAlpha = getAttribute( "SolidColor", "alpha", 1.0, 0 );
shape->setStroke( true );
shape->setStrokeWeight( solidStrokeWeight );
shape->setStrokeColor( stringToHex( fillSolidColor ) );
shape->setStrokeAlpha( fillAlpha );
ofColor c;
popTag();
popTag();
popTag();
}
}
void print_hlms_sig(char* sig)
{
hlms_sig_t decoded_hlms_signature;
decode_hlms_sig(sig,&decoded_hlms_signature);
printf("pub2:\t %s \n",stringToHex(decoded_hlms_signature.pub2,N));
printf("sig1: \n");
print_lms_sig(decoded_hlms_signature.sig1);
printf("sig2: \n");
print_lms_sig(decoded_hlms_signature.lms_sig);
free(decoded_hlms_signature.pub2);
free(decoded_hlms_signature.sig1);
free(decoded_hlms_signature.lms_sig);
}
void MainWindow::updateRequestPreview( void )
{
const int slave = ui->slaveID->value();
const int func = stringToHex( embracedString(
ui->functionCode->
currentText() ) );
const int addr = ui->startAddr->value();
const int num = ui->numCoils->value();
if( func == _FC_WRITE_SINGLE_COIL || func == _FC_WRITE_SINGLE_REGISTER )
{
ui->requestPreview->setText(
QString().sprintf( "%.2x %.2x %.2x %.2x ",
slave,
func,
addr >> 8,
addr & 0xff ) );
}
void ofxFlashXFLBuilder :: setupFillForShape ( ofxFlashShape* shape )
{
if( tagExists( "fill", 0 ) )
{
pushTag( "fill", 0 );
string fillSolidColor;
fillSolidColor = getAttribute( "SolidColor", "color", "#000000", 0 );
fillSolidColor = cleanHexString( fillSolidColor );
float fillAlpha;
fillAlpha = getAttribute( "SolidColor", "alpha", 1.0, 0 );
shape->setFill( true );
shape->setFillColor( stringToHex( fillSolidColor ) );
shape->setFillAlpha( fillAlpha );
popTag();
}
}
void print_lms_sig(char* sig)
{
unsigned int i = 0;
lms_sig_t lms_signature;
list_node_t* temp_node = NULL;
list_node_t* delete_node = NULL;
decode_lms_sig(sig, &lms_signature);
print_lmots_signature(lms_signature.lm_ots_sig);
temp_node = lms_signature.path;
while(temp_node != NULL)
{
printf("path[%d]: \t %s \n ",i,stringToHex(temp_node->data,N));
delete_node = temp_node;
temp_node = temp_node->next;
/*Lets destroy this from the face of the earth*/
free(delete_node->data);
free(delete_node);
i++;
}
}
memcpy(temp + N + N + ENTROPY_SIZE,uint32ToString(node_num/2,temp_string),4*sizeof(char));
memcpy(temp + N + N + ENTROPY_SIZE + 4,uint8ToString(D_INTR,temp_string),1);
//printf("INPUT: %s \n ",stringToHex(temp, 2*N +36));
H(temp,temp_input, N + N + ENTROPY_SIZE + 4 + 1);
}
memcpy(temp,temp_input,N);
node_num = node_num/2;
temp_node = temp_node->next;
}
/* Clean up the allocated data */
free(lm_ots_sig);
free(lms_signature.lm_ots_sig);
cleanup_link_list(lms_signature.path);
cleanup_link_list(decoded_sig.y);
D(printf("GEN PUB: %s \n",stringToHex(temp,N));)
D(printf("PUB: %s \n",stringToHex(public_key,N));)
if (compare(temp,public_key,N))
{
return 1;
}
else
{
return 0;
}
}
void cleanup_lms_key(lms_priv_key_t* lms_private_key,char* lms_public_key)
{
unsigned int q = 0;
for(q = 0; q < NUM_LEAF_NODES; q++)
{
// THE MAIN
char* main(int argc, char *argv[])
// param options:
// decrypt some aes encrypted string: enc_string key
// set a new flag d with id=a and token='b-.-c': a 'b-.-c' d
// add a new fzn with value: fzn value
{
if (strcmp(argv[1], "-h") == 0) { // decryption not really needed but management want me to leave it...
char* encrypted_flag = argv[2];
char* aeskey = argv[3];
char tmpstr[8096];
sprintf(tmpstr, "echo %s | openssl enc -d -aes-256-cbc -a -k %s", encrypted_flag, aeskey);
FILE *fp;
int status;
char path[4096];
char content[4096];
fp = popen(tmpstr, "r");
if (fp == NULL)
/* Handle error */;
fgets(path, 4096, fp);
sprintf(content, "%s", path);
if (strlen(content) < 5) {
printf("gcry_cipher_decrypt failed:");
} else {
printf("%s\n", content);
}
// dec: echo U2FsdGVkX18eaVlEUPTR47GFaEoh3u9DMHgqvtZS1Ko= | openssl enc -d -aes-256-cbc -a -k mykey
}
else if (strcmp(argv[1], "-h") == 0) { // decryption not really needed but management want me to leave it...
char* encrypted_flag = argv[2];
char* aes_key = argv[3];
//printf("encrypted_flag: %s (%i)\n", encrypted_flag, (int)(strlen(encrypted_flag)));
char* ascii_flag = hexToString(encrypted_flag);
//printf("ascii_flag: %s (%i)\n", ascii_flag, (int)(strlen(ascii_flag)));
decryptString2(ascii_flag, aes_key);
//printf("passing ascii_flag: %s (%i)\n", ascii_flag, (int)(strlen(ascii_flag)));
remPad(ascii_flag, strlen(ascii_flag));
//printf("%s\n", ascii_flag);
//printf("ascii_flag: %s (%i)\n", ascii_flag, (int)(strlen(ascii_flag)));
printf("%s\n", ascii_flag);
return ascii_flag; // is decryped
} else if (argc == 4)
{
char* flag_id = argv[1]; // FahrzeugnummerBeginnWortBeginn
char* password = argv[2]; // ( komplette Fahrzeugnummer-.-komplettes Wort )
char* content_arg = argv[3]; // the flag itself
char content[4096];
strcpy(content, content_arg);
char delimiter[] = "-.-";
char *ptr;
ptr = strtok(password, delimiter);
char* fzn = ptr;
ptr = strtok(NULL, delimiter);
char* bayWord = ptr;
char* aeskey = randstring(16);
printf("%s\n", aeskey);
char hex_content[4096];
char tmpstr[8096];
sprintf(tmpstr, "echo %s | openssl enc -e -aes-256-cbc -a -k %s", argv[3], aeskey);
FILE *fp;
int status;
char path[4096];
fp = popen(tmpstr, "r");
if (fp == NULL)
/* Handle error */;
fgets(path, 4096, fp);
sprintf(hex_content, "%s", path);
// dec: echo U2FsdGVkX18eaVlEUPTR47GFaEoh3u9DMHgqvtZS1Ko= | openssl enc -d -aes-256-cbc -a -k mykey
// printf("hex: ||%s||", hex_content);
// printf("aes: ||%s||", aeskey);
// printf("-----------");
printf("fzn: %s\n", fzn);
printf("bayWord: %s\n", bayWord);
printf("encrypted: %s\n", hex_content);
printf("aeskey: %s\n", aeskey);
// ADD TO FILES
addFznAndEncContentToFznCsv(fzn, hex_content);
// printf("Alles3: ||%s|| ; ||%s|| ; ||%s|| ; ||%s|| ; ||%s||\n", bayWord, aeskey, fzn, hex_content, aeskey);
addBayWordAndKeyToBayCsv(bayWord, aeskey);
// printf("Alles4: ||%s|| ; ||%s|| ; ||%s|| ; ./setflag -h %s %s\n", bayWord, aeskey, fzn, hex_content, aeskey);
}
else if (argc == 4) { // for managers only!!11
int done = 0;
int tries = 0;
char* flag_id = argv[1]; // FahrzeugnummerBeginnWortBeginn
char* password = argv[2]; // ( komplette Fahrzeugnummer-.-komplettes Wort )
char* content_arg = argv[3]; // the flag itself
char content[4096];
strcpy(content, content_arg);
printf("content_arg: %s (%i)\n", content_arg, (int)(strlen(content_arg)));
printf("Alles::content: %s (%i)\n", content, (int)(strlen(content)));
printf("content1: %s\n", content);
char delimiter[] = "-.-";
char *ptr;
ptr = strtok(password, delimiter);
char* fzn = ptr;
printf("fzn: %s\n", fzn);
ptr = strtok(NULL, delimiter);
char* bayWord = ptr;
printf("Alles::bayWord: %s\n", bayWord);
char aeskey[1024];
char hex_content[4096];
while (done == 0) { // some weird workaround...
tries++;
strcpy(content, content_arg);
printf("Alles0: || %i ||%s (%i)|| ; ||%s(%i)|| ; ||%s(%i)|| ; ||%s(%i)|| ; ||%s(%i)||\n", tries, bayWord, (int)(strlen(bayWord)), aeskey,(int)(strlen(aeskey)), fzn, (int)(strlen(fzn)), hex_content, (int)(strlen(hex_content)), content, (int)(strlen(content)));
// char* aeskey = randstring(16);
strcpy(aeskey, randstring(16));
printf("aeskey: ||%s||\n", aeskey);
printf("passing content: %s (%i)\n", content, (int)(strlen(content)));
addPad(content, sizeof(content));
printf("AllesX: || %i ||%s (%i)|| ; ||%s(%i)|| ; ||%s(%i)|| ; ||%s(%i)||; ||%s(%i)||\n", tries, bayWord, (int)(strlen(bayWord)), aeskey,(int)(strlen(aeskey)), fzn, (int)(strlen(fzn)), hex_content, (int)(strlen(hex_content)), content, (int)(strlen(content)));
printf("after addpad: %s (%i)\n", content, (int)(strlen(content)));
int index = 0;
printf("AllesS: ");
for (index = 0; index<strlen(content)+1; index++) {
printf("%02X", (unsigned char)content[index]);
}
printf("\n");
encryptString2(content, aeskey);
printf("AllesY: || %i ||%s (%i)|| ; ||%s(%i)|| ; ||%s(%i)|| ; ||%s(%i)||; ||%s(%i)||\n", tries, bayWord, (int)(strlen(bayWord)), aeskey,(int)(strlen(aeskey)), fzn, (int)(strlen(fzn)), hex_content, (int)(strlen(hex_content)), content, (int)(strlen(content)));
printf("after enc: %s (%i)\n", content, (int)(strlen(content)));
if (strlen(content) < 32) {
printf("strlen %i\n", (int)(strlen(content)));
int rofl = 0;
printf("As s: ||");
for (rofl = 0; rofl < 32; rofl++)
{
printf("%c", content[rofl]);
}
printf("||\nAs x02: ||");
for (rofl = 0; rofl < 32; rofl = rofl+2) {
printf("%02X", content[rofl]);
}
printf("||\n");
}
printAsHex(content);
// char* hex_content = stringToHex(content);
strcpy(hex_content, stringToHex(content));
printf("after hex: %s (%i)\n", content, (int)(sizeof(content)));
printf("Alles1: || %i ||%s (%i)|| ; ||%s(%i)|| ; ||%s(%i)|| ; ||%s(%i)||; ||%s(%i)||\n", tries, bayWord, (int)(strlen(bayWord)), aeskey,(int)(strlen(aeskey)), fzn, (int)(strlen(fzn)), hex_content, (int)(strlen(hex_content)), content, (int)(strlen(content)));
if ((( strlen(hex_content) > 0 && strlen(content) > 0 && (strlen(hex_content) % 16) == 0 && (strlen(content) % 16) == 0) ) || tries > 4 ) {
done = 1;
printf("Alles2: || %i ||%s|| ; ||%s|| ; ||%s|| ; ||%s|| ; ||%s||\n", tries, bayWord, aeskey, fzn, hex_content, aeskey);
addFznAndEncContentToFznCsv(fzn, hex_content);
printf("Alles3: || %i ||%s|| ; ||%s|| ; ||%s|| ; ||%s|| ; ||%s||\n", tries, bayWord, aeskey, fzn, hex_content, aeskey);
addBayWordAndKeyToBayCsv(bayWord, aeskey);
printf("Alles4: || %i ||%s|| ; ||%s|| ; ||%s|| ; ./setflag -h %s %s\n", tries, bayWord, aeskey, fzn, hex_content, aeskey);
}
// char tmpstr[8096];
// sprintf(tmpstr, "echo 'tries: %i || done: %i || strlen content: (%i) || hex_content: %s (%i) || content_arg: %s (%i) || ' >> setflaglog.log", tries, done, (int)(strlen(content)), hex_content, (int)(strlen(hex_content)), content_arg, (int)(strlen(content_arg)));
// popen(tmpstr, "r");
}
} else { // official functionality
char* fzn = argv[1];
char* value = argv[2];
if (fzn != NULL && value != NULL) {
addFznAndEncContentToFznCsv(fzn, value);
printf("FZN ADDED\n");
} else {
printf("you have to provide fzn and value\n");
}
}
}
