285 lines
10 KiB
C
285 lines
10 KiB
C
|
// -*- coding: utf-8 -*-
|
||
|
|
|
||
|
|
//+---------------------------------------------------------------------------+
|
||
|
|
//| 01001110 01100101 01110100 01111010 01101111 01100010 |
|
||
|
|
//| |
|
||
|
|
//| Netzob : Inferring communication protocols |
|
||
|
|
//+---------------------------------------------------------------------------+
|
||
|
|
//| Copyright (C) 2011-2017 Georges Bossert and Frédéric Guihéry |
|
||
|
|
//| This program is free software: you can redistribute it and/or modify |
|
||
|
|
//| it under the terms of the GNU General Public License as published by |
|
||
|
|
//| the Free Software Foundation, either version 3 of the License, or |
|
||
|
|
//| (at your option) any later version. |
|
||
|
|
//| |
|
||
|
|
//| This program is distributed in the hope that it will be useful, |
|
||
|
|
//| but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
||
|
|
//| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
||
|
|
//| GNU General Public License for more details. |
|
||
|
|
//| |
|
||
|
|
//| You should have received a copy of the GNU General Public License |
|
||
|
|
//| along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
||
|
|
//+---------------------------------------------------------------------------+
|
||
|
|
//| @url : http://www.netzob.org |
|
||
|
|
//| @contact : contact@netzob.org |
|
||
|
|
//| @sponsors : Amossys, http://www.amossys.fr |
|
||
|
|
//| Supélec, http://www.rennes.supelec.fr/ren/rd/cidre/ |
|
||
|
|
//+---------------------------------------------------------------------------+
|
||
|
|
|
||
|
|
//Compilation Windows
|
||
|
|
//cl -Fe_libNeedleman.pyd -Ox -Ot -openmp -LD /I"C:\Python26\include" /I"C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\include" libNeedleman.c "C:\Python26\libs\python26.lib" "C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\lib\vcomp.lib"
|
||
|
|
|
||
|
|
//+---------------------------------------------------------------------------+
|
||
|
|
//| Import Associated Header
|
||
|
|
//+---------------------------------------------------------------------------+
|
||
|
|
#include "libNeedleman.h"
|
||
|
|
#include <time.h>
|
||
|
|
#ifdef _WIN32
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <malloc.h>
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// The Python callback
|
||
|
|
extern PyObject *python_callback;
|
||
|
|
|
||
|
|
static PyMethodDef libNeedleman_methods[] = {
|
||
|
|
{"getBID", py_getBID, METH_NOARGS, NULL},
|
||
|
|
{"alignTwoMessages", py_alignTwoMessages, METH_VARARGS, NULL},
|
||
|
|
{"alignMessages", py_alignMessages, METH_VARARGS, NULL},
|
||
|
|
{NULL, NULL, 0, NULL}
|
||
|
|
};
|
||
|
|
|
||
|
|
//+---------------------------------------------------------------------------+
|
||
|
|
//| initlibNeedleman : Python will use this function to init the module
|
||
|
|
//+---------------------------------------------------------------------------+
|
||
|
|
PyObject* PyInit__libNeedleman(void) {
|
||
|
|
static struct PyModuleDef moduledef = {
|
||
|
|
PyModuleDef_HEAD_INIT,
|
||
|
|
"_libNeedleman",
|
||
|
|
NULL,
|
||
|
|
-1,
|
||
|
|
libNeedleman_methods,
|
||
|
|
NULL,
|
||
|
|
NULL,
|
||
|
|
NULL,
|
||
|
|
NULL
|
||
|
|
};
|
||
|
|
|
||
|
|
return PyModule_Create(&moduledef);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+---------------------------------------------------------------------------+
|
||
|
|
//| py_alignSequences : Python wrapper for alignMessages
|
||
|
|
//+---------------------------------------------------------------------------+
|
||
|
|
PyObject* py_alignMessages(__attribute__((unused))PyObject* self, PyObject* args) {
|
||
|
|
|
||
|
|
// parameters
|
||
|
|
PyObject* wrapperFactory;
|
||
|
|
t_message *messages;
|
||
|
|
PyObject *temp_cb;
|
||
|
|
unsigned int doInternalSlick = 0;
|
||
|
|
unsigned int debugMode = 0;
|
||
|
|
|
||
|
|
// local variables
|
||
|
|
t_message * resMessage;
|
||
|
|
unsigned int nbMessages = 0;
|
||
|
|
Bool bool_debugMode;
|
||
|
|
Bool bool_doInternalSlick;
|
||
|
|
int parseRet;
|
||
|
|
t_score score;
|
||
|
|
|
||
|
|
// Converts the arguments
|
||
|
|
if (!PyArg_ParseTuple(args, "hOhO", &doInternalSlick, &temp_cb, &debugMode, &wrapperFactory)) {
|
||
|
|
PyErr_SetString(PyExc_TypeError, "Error while parsing the arguments provided to py_alignMessages");
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------------+
|
||
|
|
// Verify the callback parameter
|
||
|
|
//+------------------------------------------------------------------------+
|
||
|
|
if (!PyCallable_Check(temp_cb)) {
|
||
|
|
PyErr_SetString(PyExc_TypeError, "The provided 2nd parameter should be a callback.");
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
// Parse the callback
|
||
|
|
Py_XINCREF(temp_cb); /* Add a reference to new callback */
|
||
|
|
Py_XDECREF(python_callback); /* Dispose of previous callback */
|
||
|
|
python_callback = temp_cb; /* Remember new callback */
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------------+
|
||
|
|
// Deserializes the provided arguments
|
||
|
|
//+------------------------------------------------------------------------+
|
||
|
|
if (debugMode == 1) {
|
||
|
|
printf("py_alignSequences : Deserialization of the arguments (format, serialMessages).\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
parseRet = parseArgs(wrapperFactory,&nbMessages,&messages);
|
||
|
|
//Parsing error: PyErr allready set in parseArgs
|
||
|
|
if(parseRet){
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Convert debugMode parameter in a BOOL
|
||
|
|
if (debugMode) {
|
||
|
|
bool_debugMode = TRUE;
|
||
|
|
} else {
|
||
|
|
bool_debugMode = FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (debugMode == TRUE) {
|
||
|
|
printf("A number of %d messages have been deserialized.\n", nbMessages);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Concert doInternalSlick parameter in a BOOL
|
||
|
|
if (doInternalSlick) {
|
||
|
|
bool_doInternalSlick = TRUE;
|
||
|
|
} else {
|
||
|
|
bool_doInternalSlick = FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Fix the default values associated with resMessage
|
||
|
|
resMessage = (t_message *) malloc(sizeof(t_message));
|
||
|
|
score.s1 = 0;
|
||
|
|
score.s2 = 0;
|
||
|
|
score.s3 = 0;
|
||
|
|
resMessage->score = &score;
|
||
|
|
resMessage->alignment = malloc(messages[0].len * sizeof(unsigned char));
|
||
|
|
resMessage->semanticTags = malloc(messages[0].len * sizeof(t_semanticTag*));
|
||
|
|
for (unsigned int i=0; i<messages[0].len; i++) {
|
||
|
|
resMessage->semanticTags[i] = malloc(sizeof(t_semanticTag));
|
||
|
|
}
|
||
|
|
memset(resMessage->alignment, '\0', messages[0].len);
|
||
|
|
//+------------------------------------------------------------------------+
|
||
|
|
// Execute the alignment process
|
||
|
|
//+------------------------------------------------------------------------+
|
||
|
|
int t=clock();
|
||
|
|
alignMessages(resMessage, bool_doInternalSlick, nbMessages, messages, bool_debugMode);
|
||
|
|
int t1=clock();
|
||
|
|
|
||
|
|
if (debugMode == 1) {
|
||
|
|
printf ("It took %f operation to align messages.\n",(float)(t1-t)/CLOCKS_PER_SEC);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Return the serialization of the message
|
||
|
|
return serializeMessage(resMessage);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//+---------------------------------------------------------------------------+
|
||
|
|
//| py_alignTwoMessages : Python wrapper for alignTwoMessages
|
||
|
|
//+---------------------------------------------------------------------------+
|
||
|
|
PyObject* py_alignTwoMessages(__attribute__((unused))PyObject* self, PyObject* args) {
|
||
|
|
// Parameters (in order)
|
||
|
|
unsigned int doInternalSlick = 0;
|
||
|
|
char *format;
|
||
|
|
int sizeFormat;
|
||
|
|
unsigned char *serialMessages;
|
||
|
|
int sizeSerialMessages;
|
||
|
|
unsigned int debugMode = 0;
|
||
|
|
|
||
|
|
// local variables
|
||
|
|
unsigned int nbDeserializedMessage = 0;
|
||
|
|
t_message message1;
|
||
|
|
t_score scoreMessage1;
|
||
|
|
t_message message2;
|
||
|
|
t_score scoreMessage2;
|
||
|
|
t_message resMessage;
|
||
|
|
t_score score;
|
||
|
|
t_group group;
|
||
|
|
Bool bool_doInternalSlick;
|
||
|
|
Bool bool_debugMode;
|
||
|
|
|
||
|
|
// Converts the arguments
|
||
|
|
if (!PyArg_ParseTuple(args, "hs#s#h", &doInternalSlick, &format, &sizeFormat, &serialMessages, &sizeSerialMessages, &debugMode)) {
|
||
|
|
PyErr_SetString(PyExc_TypeError, "Error while parsing the arguments provided to py_alignTwoMessages");
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------------+
|
||
|
|
// Deserializes the provided arguments
|
||
|
|
//+------------------------------------------------------------------------+
|
||
|
|
if (debugMode == 1) {
|
||
|
|
printf("The following arguments were received : \n");
|
||
|
|
printf("doInternalSlick : %d\n", doInternalSlick);
|
||
|
|
printf("Format :\n");
|
||
|
|
hexdump((unsigned char*)format, sizeFormat);
|
||
|
|
printf("Serial :\n");
|
||
|
|
hexdump(serialMessages, sizeSerialMessages);
|
||
|
|
printf("Debug mode : %d\n", debugMode);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Deserialization of messages
|
||
|
|
group.len = 2;
|
||
|
|
group.messages = malloc(2*sizeof(t_message));
|
||
|
|
|
||
|
|
nbDeserializedMessage = deserializeMessages(&group, format, serialMessages, 2, debugMode);
|
||
|
|
|
||
|
|
if (nbDeserializedMessage != 2) {
|
||
|
|
printf("Error : impossible to deserialize all the provided messages.\n");
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------------+
|
||
|
|
// Execute the alignment of two messages
|
||
|
|
//+------------------------------------------------------------------------+
|
||
|
|
// Convert debugMode parameter in a BOOL
|
||
|
|
if (debugMode) {
|
||
|
|
bool_debugMode = TRUE;
|
||
|
|
} else {
|
||
|
|
bool_debugMode = FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Concert doInternalSlick parameter in a BOOL
|
||
|
|
if (doInternalSlick) {
|
||
|
|
bool_doInternalSlick = TRUE;
|
||
|
|
} else {
|
||
|
|
bool_doInternalSlick = FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Establishes message1
|
||
|
|
message1.len = group.messages[0].len;
|
||
|
|
scoreMessage1.s1 = 0;
|
||
|
|
scoreMessage1.s2 = 0;
|
||
|
|
scoreMessage1.s3 = 0;
|
||
|
|
message1.score = &scoreMessage1;
|
||
|
|
message1.alignment = group.messages[0].alignment;
|
||
|
|
message1.mask = malloc(group.messages[0].len * sizeof(unsigned char));
|
||
|
|
memset(message1.mask, 0, group.messages[0].len);
|
||
|
|
|
||
|
|
// Establishes message2
|
||
|
|
message2.len = group.messages[1].len;
|
||
|
|
scoreMessage2.s1 = 0;
|
||
|
|
scoreMessage2.s2 = 0;
|
||
|
|
scoreMessage2.s3 = 0;
|
||
|
|
message2.score = &scoreMessage2;
|
||
|
|
message2.alignment = group.messages[1].alignment;
|
||
|
|
message2.mask = malloc(group.messages[1].len * sizeof(unsigned char));
|
||
|
|
memset(message2.mask, 0, group.messages[1].len);
|
||
|
|
|
||
|
|
// Prepare the response
|
||
|
|
resMessage.len = 0;
|
||
|
|
score.s1 = 0;
|
||
|
|
score.s2 = 0;
|
||
|
|
score.s3 = 0;
|
||
|
|
resMessage.score = &score;/*
|
||
|
|
if (message1.len >= message2.len) {
|
||
|
|
resMessage.mask = malloc(message1.len * sizeof(unsigned char));
|
||
|
|
memset(resMessage.mask, 0, message1.len);
|
||
|
|
resMessage.alignment = malloc(message1.len * sizeof(unsigned char));
|
||
|
|
memset(resMessage.alignment, 0, message1.len);
|
||
|
|
} else {
|
||
|
|
resMessage.mask = malloc(message2.len * sizeof(unsigned char));
|
||
|
|
memset(resMessage.mask, 0, message2.len);
|
||
|
|
resMessage.alignment = malloc(message2.len * sizeof(unsigned char));
|
||
|
|
memset(resMessage.alignment, 0, message2.len);
|
||
|
|
}*/
|
||
|
|
// Execute the C function
|
||
|
|
alignTwoMessages(&resMessage, bool_doInternalSlick, &message1, &message2, bool_debugMode);
|
||
|
|
|
||
|
|
free(message1.mask);
|
||
|
|
free(message2.mask);
|
||
|
|
|
||
|
|
// Return the result
|
||
|
|
return serializeMessage(&resMessage);
|
||
|
|
}
|
||
|
|
|