Justo ayer hice una POC sobre ello: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Saludos 

Buenas a todos 


La última versión que publiqué en este foro fue la 0.2, han habido muchos cambios desde entonces y 4 versiones más (las mejoras se mantienen entre versiones), publico los changelogs de todas las versiones y dejaré links a la 0.5 y 0.6. La más estable y la que más se ha testeado es la 0.5, pero la 0.6 supone el inicio de una serie de funcionalidades diferentes como la reordenación de código.



Se han solucionado problemas, mejorado la interfaz y extendido la funcionalidad, además, ahora es posible traducir fácilmente la salida del script modificando System/Kernel/Messages.py, si alguien se ofrece para traducir a varios idiomas no estaría mal  .




· Arreglados bugs con los ofuscados de strings (replace,reverse,flip_two,split,rotate), shuffle sigue dando problemas.
· Mejorado el ofuscado de strings.
· Arreglados bugs con los ofuscados de nombres de variables.
· Arreglado bug al eliminar comentarios que empiezan por # (hash).
· Arreglado bug al eliminar comentarios que empiezan por ;
· Añadidos snippets de [ Debe registrarse para ver este enlace ] como funciones hardcodeadas.
· Añadida función para llamar a las funciones hardcodeadas.
· Añadido nuevo método de ofuscado de strings, hexify (BinaryToString , StringToBinary). La longitud de las strings, con este método, se duplica, si supera el tamaño máximo de linea (Unterminated string) usar junto método split.
· Arreglados bugs al añadir funciones hardcodeadas.
· Extraídos mensajes para permitir traducciones.
· Cambiado el aspecto de la salida por consola.




Traigo la 4º actualización del ofuscador donde, además de añadir funciones y solucionar algunos problemas, se han hecho cambios en la interfaz y en el modo de uso de la aplicación.

En primer lugar, se ha compilado el código del ofuscador y generado un ejecutable (OBFAU3.exe), ahora solo es necesario lanzar el ejecutable (NO SE REQUIERE Python, probado en Win7/10 64 bits) con los parámetros adecuados. Con respecto a estos parámetros, en la versión actual se deben especificar en el fichero config.ini respetando los tipos de datos que se dan como ejemplo. Además, como se puede ver el fichero config.ini mencionado, ya es posible utilizar las traducciones que se añadan a Languages (de momento español, inglés y portugués)



· Añadido fichero de configuración del proceso. Todos los parámetros se gestionan ahora desde config.ini.

· Traducción al Español y Portugués (este último no funciona pero está realizada la traducción).

· Posibilidad de cambiar de idioma.

· Ocultados parámetros de funciones.

· Soporte a ByRef y valores por defecto en parámetros de funciones.

· Mejorada la estabilidad en la ofuscación de nombres de variables, funciones y parámetros.

· Generado ejecutable.

· Añadidos todos los snippets AutoIt ([ Debe registrarse para ver este enlace ]) sin dependencias ni efectos visibles (+30).

· Arreglado método shuffle para ocultar strings. Cuidado con las combinaciones, duplica el tamaño de las strings.

· Detectados problemas en algunas funciones hardcodeadas (se depurará en la siguiente versión).



Comento para publicar la nueva versión del proyecto, que, en principio, será la última a no ser que sigan surgiendo ideas. La actualización se ha dedicado a solucionar problemas con las funciones hardcodeadas y los parámetros, además ahora se permite compilar directamente desde el ofuscador sin necesidad de abrir Aut2Exe. Se han realizado pruebas con más scripts y ha funcionando perfectamente en todos con muy buenos resultados, dejo el changelog.



· Arregladas las funciones hardcodeadas (junto con la adición de bloques aleatorios pueden darse situaciones que corrompan el script, volver a ofuscar o reducir el número de funciones hardcodeadas).

· Error Unable to parse line, se soluciona volviendo a ejecutar el script ofuscado.

· Arreglado bug al ocultar parámetros de funciones hardcodeadas (ahora no se ocultan en estas funciones).

· Algunos problemas se solucionan por la profundidad de ofuscado de números (recomendado entre 1 y 2 o entre 1 y 1).

· Realizadas pruebas con más scripts (los resultados han sido muuy buenos).

· Compilación automática de los scripts con Aut2Exe y posibilidad de cambiar parámetros de compilación en config.ini.

· Mejorado el procesamiento de parámetros.



En este caso los cambios son orientados a incrementar la variabilidad del código generado y del original, complicando aun más los bloques While y Do until, también se han añadido condiciones adicionales en las guardas de los bloques condicionales y bucles así como modificaciones de los objetos creados en los bloques With y bucles For ... In. Además ahora se ofusca más el código original, sustituyendo la parte derecha de las expresiones de asignación por una llamada a Execute, pudiendo ofuscar también estas expresiones con los ocultadores de cadenas ya existentes (esto también es aleatorio, según una distribución uniforme se decide si se ofusca o no, de esta manera, una asignación). Se ha implementado también otro método para ofuscar asignaciones usando Assign, pero no recomiendo su uso porque se ha probado poco y no ha funcionado correctamente. Junto con todo esto, se han añadido también más snippets Autoit como funciones hardcodeadas, que tampoco han sido depuradas y pueden ocasionar problemas por lo que se recomienda, al menos en esta versión, no añadir una gran cantidad de funciones de este tipo (del orden de 1 a 10 está bien.)



· Añadido icono a ejecutable.

· True statements en ambos lados.

· Completado Whiles y Do Until con más de una expresión .

· Añadidas en bloques with modificaciones de objetos.

· Arreglados While y Do Until.

· Añadidos iconos aleatorios (Requiere PIL [ Debe registrarse para ver este enlace ])

· Añadidas más funciones hardcodeadas (+15 de [ Debe registrarse para ver este enlace ], no se han depurado, pueden no funcionar bien si se añaden muchas!).

· Cambiadas expresiones usando Execute.

· Cambiadas asignaciones usando Assign (no he conseguido que preserve la semántica, puede no funcionar bien).

· Aleatorizado el cambio de expresiones.


Destacar que esta versión es menos estable que la anterior pero puede proporcionar mejores resultados por las modificaciones en el código, además facilita la compilación y la utilización de iconos aleatorios. Puede verse como primera versión de una nueva rama en la que se implementará la reordenación de código y otras mejoras más.


Con ello, dejo las descargas.



Versión 0.5, ejecutable: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Versión 0.6, ejecutable por SendSpace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Versión 0.6, código fuente:  No tienes permitido ver los links. Registrarse o Entrar a mi cuenta



Dejo, además, una prueba del funcionamiento de la versión 0.5.






No me hago responsable del uso que se le dé y se libera con fines educativos, cualquier duda en el código o en el uso, no dudéis en preguntar 

Buenas a todos 

LLevo unos cuantos dias trabajando en un ofuscador de AutoIt en Python. Lo libero porque un proyecto de ofuscadores online que planteamos entre Blau, Sanko y yo ha quedado en nada, espero que os sirva de algo.

Actualmente las características son las siguientes:

Características del proceso:

· Número de iteraciones del proceso de ofuscado.
· Enlazar includes desde otros ficheros del proyecto.
· Eliminar comentarios especificados por tags (comment-start/comment-end y cs/ce)
· Eliminar comentarios especificados por ;
· Eliminar regiones (#Region)
· Añadir nuevas regiones
· Ocultar nombres de variables
· Ocultar nombres de funciones
· Añadir funciones hardcodeadas especificadas en Hardcoded/HardcodedPrograms.py
· Añadir variables
· Añadir comentarios
· Añadir bloques de código generado al inicio
· Añadir bloques de código generado al final
· Añadir bloques de código generado entre lineas del código original.
· Añadir funciones
· Añadir llamadas a funciones
· Ocultar strings con método replace.
· Ocultar strings con método shuffle (genera codigo autoit para desordenar y ordenar las strings).
· Ocultar strings con método cipher  (medio implementado por problemas con la salida de los algoritmos de PyCrypto).
· Ocultar strings con método reverse.
· Ofuscar enteros.
· Añadir directivas,  incluido #pragma compile con datos generados.
· Añadir espacios y tabuladores en el código.
· Añadir símbolos en el EOF.

Características de los bloques de código generados (según una aproximación a la gramática de AutoIt):

· Generación de código y bloques if, for ... to, for ... in, with, switch, func y simple (definiciones de nuevas variables haciendo uso de macros, constantes ofuscadas,  funciones del lenguaje de aridades 0, 1 y 2 y valores de tipos básicos)
· Definición del número mínimo y máximo de bloques a añadir.
· Definición del número mínimo y máximo de sentencias a añadir dentro del bloque (estas sentencias pueden ser a su vez nuevos bloques).
· Definición del número mínimo y máximo de condiciones lógicas a añadir en la guarda de los bloques generados.
· Definición del número mínimo y máximo de ElseIf dentro de un bloque If.
· Definición de la profundidad máxima de anidamiento de bloques generados.
· Definición de los valores mínimo y máximo de los enteros a usar en las definiciones (tiene sentido cuando se combina con la ofuscación de números).
· Posibilidad de añadir bloques al inicio,  al final y entre medias del código original.
· Definición de la probabilidad de generación de nuevos bloques entre medias del código original.
· Definición del número mínimo y máximo de funciones a añadir.
· Definición de la aridad mínima y máxima de las funciones a añadir (define el número de parámetros de una función).
· Es necesario especificar todos estos valores en las tres posibilidades de adición de bloques (inicio, final, medio).

Otras características:

· Definición de la profundidad máxima en el ofuscado de enteros.
· Definición del tamaño en KB de la secuencia de símbolos a añadir tras el EOF.
· Variables declaradas con Local,  Dim y Global.
· Considerado Call en las llamadas a funciones. (Considerar que el usuario pueda desactivarlo)
· Considerado Assign en las definiciones de variables. (Considerar que el usuario pueda desactivarlo)
· Considerado Eval. (Considerar que el usuario pueda desactivarlo)
· Considerada la creación y uso de objetos COM.
· Alterar nombres de las funciones y palabras clave de AutoIt (Considerar que el usuario pueda desactivarlo)
· Posibilidad de combinar los métodos de ofuscado de strings disponibles.
· Todos los parámetros de los procesos son elegidos de forma aleatoria entre los valores límite especificados por el usuario (incrementa la dispersión y permite incrementar la exploración del espacio de soluciones si se emplean algoritmos genéticos para optimizar los parámetros).
· Implementado operador ternario (parece funcionar solo con algunas versiones de AutoIt, dar posibilidad de activarlo)


Además, pretendo llevar adelante el proyecto hasta al menos el 25 de este mes que empiece el máster por lo que intentaré añadir en futuras versiones:

Pendiente de añadir:

· Algoritmo genético para optimizar los parámetros del proceso.
· GUI (Sadfud y Blau)
· Compilar automáticamente con Aut2Exe y variar sus parámetros (compresión,  iconos,  ...)
· Considerar arrays.
· Considerar constantes y enumeraciones (const y enum). (Reparando bugs)
· Arreglar bug al añadir directivas (mismo include dos veces).
· Parametrizar el script principal (standalone)
· Reordenación de código (tengo planteado algo usando grafos para tener en cuenta las dependencias).
· Dar la posibilidad de especificar más parámetros como el tamaño de los identificadores generados (esto se considera en las funciones implementadas pero no se deja al usuario especificarlo,   puede reducir considerablemente el tamaño del código).
· Hardcodear instancias simples de problemas NP.

He podido identificar una serie de errores que tienen solución simplemente usando bien el ofuscador, sin embargo es posible que haya algunos errores permanentes si usáis alguna función que no se comporte correctamente con un script dado, ante ese problema desactivad la función, variad los límites de dicha función o esperad hasta una nueva versión. Algunos de los errores conocidos son:

· Duplicate name (function) 
    · Problema: Repetición del nombre de alguna función (al parecer ocurre cuando se añaden directivas include repetidas).
    · Solución: Volver a ejecutar el ofuscador (desactivar la función de añadir directivas).
    
· Error in expresion        
    · Problema: Error en algún Switch generado
    · Solución: Volver a ejecutar el ofuscador.
    
· Error subscripted array   
    · Problema: Error general, fuente desconocida.
    · Solución: Volver a ejecutar el ofuscador, error general, fuente desconocida.

· Undefined variable        
    · Problema: Se hace uso de una variable no definida en alguna evaluación. 
		Generalmente ocurre cuando se intentan ocultar variables y se hace uso en el código de constantes AutoIt.
    · Solución: Desactivar la función de ocultar variables. (Intentad volviendo a ejecutar el ofuscador)

· Only Object-type variables allowed in a "With" statement 
    · Problema: La variable especificada en la guarda del bloque With no es un objeto.
		Ocurre por una inicialización incorrecta de es tipo de bloques.
    · Solución: Volver a ejecutar el ofuscador.

· Variable must be of type "Object" 
    · Problema: Alguna variable no es del tipo esperado (Object) en alguna expresión. Fuente desconocida.
    · Solución: Volver a ejeutar el ofuscador.
    
· Ante cualquier otro error, volver a ofuscar y variar parámetros. Si se soluciona (o no), publicadlo en el post :).

Si obtenéis un error diferente a los conocidos, intentad variar los parámetros o desactivar las funciones del ofuscador que supongáis que ocasionan el problema. Hay que tener cierta maña para usarlo y darse cuenta de qué funciones y parámetros provocan cada error, no os desaniméis si no funciona a la primera :boxing: . Además, podéis escribir el error en el post para que pueda darle solución en futuras versiones o daros alguna recomendación de uso.

Con respecto al código, podéis descargarlo de mi No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, es ahí donde subiré las actualizaciones (avisaré también por aquí). Para usar esta versión solo tenéis que cambiar los parámetros en No tienes permitido ver los links. Registrarse o Entrar a mi cuenta y ejecutar el script.


Además, Sadfud y Blau han colaborado haciendo una GUI cada uno, de momento solo está la de Sadfud y tiene algunos problemas que yo haya podido comprobar (funciona con una versión anterior del código, salta Avira y solo deja ofuscar un fichero en cada ejecución de la interfaz).



De momento recomiendo usar directamente el script de mi No tienes permitido ver los links. Registrarse o Entrar a mi cuenta variando los parámetros correctamente para cada script AutoIt, aunque si no es posible tenéis la GUI de Sadfud.

No me hago responsable del uso que le déis a la herramienta :banned: , espero que os sea útil :drinking: .


Aprovecho para dejar los links de la nueva versión por No tienes permitido ver los links. Registrarse o Entrar a mi cuenta y No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.


    · Añadidos bloques For ... In, With, While y Do ... Until.
    · Creación y uso de objetos COM.
    · Operador ternario.
    · Enums y consts (bug).
    · Reparado el bug al ocultar variables no definidas por el usuario.
    · Considerado Step en bucles For ... To.
    · Añadidas cuatro funciones hardcodeadas.
    · Añadido método split para ofuscar strings.
    · Actualizada la lista de errores y soluciones.

Dejo también algunas consideraciones sobre el uso de la herramienta:

    · replace_includes : No activarla a no ser que el script a ofuscar incluya otros scripts desarrollados por el usuario (no de AutoIt). Si se activa y no se da esa situación siempre corrompe.

    · rm_comments_by_tag , rm_comments_by_semicolon y rm_comments_by_hash : Usar el adecuado para el script en función de cómo se definan los comentarios. Hay algunas situaciones que sí lo hacen corromper, en esta situación no vale con volver a ofuscar, hay que desactivar la función.

    · rm_regions , add_regs , hide_func_names , hide_var_names , add_hard_funcs , add_vars , add_comm , add_init_blocks , add_end_blocks , add_mid_blocks , add_user_funcs y add_func_calls : Estas funciones generan código de forma más o menos controlada, todos los errores observados que provocan se solucionan volviendo a ofuscar (al generar código de forma aleatoria entre los límites de los parámetros se pueden dar condiciones concretas que corrompen), por lo que en principio no hay porqué desactivar estas funciones siempre que los valores de los parámetros sean adecuados (evitar bestialidades de poner millones de bloques con profundidades de anidamiento exageradas etc.).

    · hide_strings_replace, hide_strings_flip_two, hide_strings_reverse, hide_strings_split : Ocultan cualquier string que aparezca en el código usando varios métodos, en principio tampoco hay problema en mantenerlas activadas.

    · hide_strings_shuffle : No oculta cualquier string, solo aquellas que se utilizan para dar valor a alguna variable e.g. Local $a = "string". Sí que suele dar problemas, recomiendo no usarla hasta que la depure bien.

    · hide_numbers : Oculta enteros, no genera ningún error.

    · add_directives : Puede generar errores por nombres duplicados si repite includes, el problema se soluciona volviendo a ofuscar hasta que no se de esa condición o desactivando la función(tiene fácil solución lo arreglaré en la siguiente versión).

    · add_tabs, add_to_eof : La primera sustituye espacios del código original por un número aleatorio de tabuladores, la segunda añade símbolos sin sentido (_) al final del script. En algunos scripts provoca errores permanentes y en otros no, posiblemente debido a la versión de AutoIt.



Se ha realizado otra actualización, esta vez orientada a solucionar problemas y a reducir la complejidad de uso, aunque se han añadido ciertas funciones adicionales .


· Añadidas condiciones siempre ciertas en el código inicial.

· Expresiones regulares precompiladas.

· Añadidas más funciones hardcodeadas.

· Añadido método rotate para ofuscado de strings.

· Arreglado bug en hide var names.

· Arreglado bug en hide func names.

· Arreglado bug en true guard statements.

· Arreglado Error in expresion.

· Arreglado Only Object-type variables allowed in a "With" statement.

· Arreglado Variable must be of type "Object".

· Detectada la fuente de subscripted array (alguna de las funciones hardcodeadas).

· Mejorada la estabilidad.

Como siempre, los links de la nueva versión por No tienes permitido ver los links. Registrarse o Entrar a mi cuenta y en mi No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.

Eso es todo, espero que sea de utilidad 

Buenas a todos, hacía tiempo que no me pasaba por aquí, siempre es un placer .

Después de un fin de semana de descanso de exámenes y aprovechando la temática del proyecto de fin de carrera pensé en aplicar la misma técnica que empleo para topic detection a detección de malware.

El proceso muy por encima consiste en extraer la "semántica" (mediante word2vec) de las instrucciones de un conjunto de programas de entrenamiento P (y por tanto de un programa completo, si modelamos por ejemplo la semántica de un programa como una combinación lineal de las semánticas de las instrucciones que lo componen) para construir una representación en un espacio continuo n-dimensional junto con otras características como por ejemplo las DLLS y las funciones de las que hace uso, una medida de empaquetamiento (ponderando la entropía y la aparición de secciones que dejan ciertos packers) entre otras que se pueden tener en cuenta (de momento solo son esas).

Una vez se tienen las representaciones vectoriales de las muestras de entrenamiento (prototipos) se emplea clasificación por vecinos más cercanos (NearestCentroid) para determinar si un determinado programa es malware o no (semántica del programa más cercana a las muestras malware o a las muestras no malware).

El código lo podéis clonar de su propio repo:
No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Instalad primero las dependencias mediante el No tienes permitido ver los links. Registrarse o Entrar a mi cuenta . Cuando estén instaladas tendréis que entrenar el sistema con vuestras propias muestras (no paso los ficheros de entrenamiento porque ocupan bastante si lo entrenas con muchas muestras) tenéis que meter muestras malware en ./Train/Malware y muestras no malware en ./Train/NoMalware y después indicarle al sistema que queréis entrenar, en el usage se muestra la forma de hacerlo, pero básicamente tenéis que lanzar lo siguiente:

python No tienes permitido ver los links. Registrarse o Entrar a mi cuenta --train ./Train/Malware ./Train/NoMalware prototypes.trained model_w2v.mm No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Cuando el sistema esté entrenado, ya podéis clasificar ejecutables indicándole al sistema que queréis predecir la clase de una muestra:

python No tienes permitido ver los links. Registrarse o Entrar a mi cuenta --predict EJECUTABLE.exe 1 prototypes.trained No tienes permitido ver los links. Registrarse o Entrar a mi cuenta No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Los 3 últimos parámetros son los ficheros generados durante el entrenamiento (si le cambiáis el nombre acordaos de ellos), y el 3º (el de valor 1) es el número de vecinos a tener en cuenta en la clasificación, podéis probar más de 1 valor si sois curiosos y si no dejadlo así.

Esto es lo necesario para poner en marcha la clasificación, podéis comprobar la precisión y otras medidas del sistema sin tener que hacer el entrenamiento, solo poned las muestras malware y no malware donde dije y lanzad lo siguiente:

python No tienes permitido ver los links. Registrarse o Entrar a mi cuenta --statistics -lou 1 ./Train/Malware ./Train/NoMalware

Con ello indicamos al sistema que queremos sacar estadísticas, haciendo leaving one out, comprobando la precisión entrenando con todas las muestras menos 1 y esa usarla como test para ver si acierta o no, para toda muestra, usando para eso 1 vecino más cercano. Todos los resultados que indiquen porcentajes están entre 0 y 1 (multiplicadlo por 100 xD).


Para que veáis las salidas del programa en los casos que os he comentado adjunto un par de imágenes:

Estadísticas:   
Clasificación: 
Predicción:     

Buenas a todos, hacia ya tiempo que no me pasaba por ningún foro  .

Después de unas cuantas horas invertidas en la creación de un detector de malware para aplicaciones Android (APK), veo que ya hay algo más o menos estable y me he decidido a hacer un post para publicar y comentar el sistema.

Como ya he dicho se trata de un detector de malware para .apk empleando en este caso algoritmos de aprendizaje automático. 

Para ver visualmente un proceso similar No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Este es un problema de clasificación en 2 clases (Malware,NoMalware)  por lo que se tienen muestras de entrenamiento para Malware (que se colocarán en Samples/RAW/Train/Malware) y muestras de entrenamiento para NoMalware (Samples/RAW/Train/NoMalware) además de las muestras para test (las que se quiere comprobar si son malware o no, en Samples/RAW/Test/), todo en .apk .

De forma sencilla, de cada apk del conjunto de datos de entrenamiento y del conjunto de datos de test se extraen características en un espacio
, las características que se extraen de cada aplicación son:

 BOOT_COMPLETED
 ACTION_SENDTO
 ACTION_SEND
 ACTION_SEND_MULTIPLE
 ACTION_GET_CONTENT
 ACTION_IMAGE_CAPTURE
 ACTION_VIDEO_CAPTURE
 ACTION_VIEW
 ACTION_INSERT
 ACTION_OPEN_DOCUMENT
 ACTION_CREATE_DOCUMENT
 ACTION_VIEW
 INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH
 ACTION_CREATE_NOTE
 SEARCH_ACTION
 ACTION_WEB_SEARCH
 ACTION_SETTINGS
 ACTION_WIRELESS_SETTINGS
 ACTION_WIFI_SETTINGS
 ACTION_APN_SETTINGS
 ACTION_BLUETOOTH_SETTINGS
 ACTION_DATE_SETTINGS
 ACTION_LOCALE_SETTINGS
 ACTION_INPUT_METHOD_SETTINGS
 ACTION_DISPLAY_SETTINGS
 ACTION_SECURITY_SETTINGS
 ACTION_LOCATION_SOURCE_SETTINGS
 ACTION_INTERNAL_STORAGE_SETTINGS
 ACTION_MEMORY_CARD_SETTINGS

 READ_CALENDAR
 WRITE_CALENDAR
 CAMERA
 READ_CONTACTS
 WRITE_CONTACTS
 GET_ACCOUNTS
 ACCESS_FINE_LOCATION
 ACCESS_COARSE_LOCATION
 RECORD_AUDIO
 READ_PHONE_STATE
 CALL_PHONE
 READ_CALL_LOG
 WRITE_CALL_LOG
 ADD_VOICEMAIL
 USE_SIP
 PROCESS_OUTGOING_CALLS
 BODY_SENSORS
 SEND_SMS
 RECEIVE_SMS
 READ_SMS
 RECEIVE_WAP_PUSH
 RECEIVE_MMS
 SEND_MMS
 READ_EXTERNAL_STORAGE
 WRITE_EXTERNAL_STORAGE


*chmod*
*/system/app*
*/system/bin/*
*remount*
*pm install*
*chown*
*mount*

Ldalvik/system/DexClassLoader
Ljava/security/spec/KeySpec

Landroid/telephony/TelephonyManager/ and getDeviceId
Landroid/telephony/TelephonyManager/ and getCellLocation
Landroid/telephony/TelephonyManager/ and getSimSerialNumber
Landroid/telephony/TelephonyManager/ and getSubscriberId
Landroid/telephony/TelephonyManager/ and getCallState
Landroid/telephony/TelephoneManager/ and getSimOperator*
Landroid/telephony/TelephoneManager/ and getLine1Number
Landroid/telephony/TelephonyManager/ and getNetworkOperator*
Landroid/telephony/gsm/SmsManager and sendTextMessage

Landroid/content/pm/PackageManager and getInstalledPackages

Landroid/app/ActivityManager and getMemoryInfo
Landroid/app/ActivityManager and getRunningServices
Landroid/app/ActivityManager and restartPackage
Landroid/app/ActivityManager and getRunningAppProcesses


Landroid/content/BroadcastReceiver and abortBroadcast

Landroid/content/Context and getApplicationInfo
Landroid/content/Context and startService
Landroid/content/Context and getFilesDir

Landroid/content/ContentResolver and insert
Landroid/content/ContentResolver and query
Landroid/content/ContentResolver and delete


Landroid/os/Handler and sendMessage
Landroid/os/Handler and obtainMessage

Landroid/os/Process and myPid
Landroid/os/Process and killProcess

Ljava/io/File and delete
Ljava/io/File and exists
Ljava/io/File and listFiles


Landroid/net/ConnectivityManager/getNetworkInfo

Landroid/net/NetworkInfo/ and getState
Landroid/net/NetworkInfo/ and isConnected

Landroid/net/WifiManager/ and getWifiState
Landroid/net/WifiManager/ and setWifiEnabled

Ljava/Runtime and getRuntime and exec
Ljava/lang/System and loadLibrary
Ljava/lang/reflect
Ljava/util/zipZipInputStream
Ljavax/crypto/
}

El sistema permite 2 enfoques, resolver el problema usando métodos no supervisados (clustering con K-medias) y usando métodos supervisados (kernel perceptron, K nearest neighbours, clasificador multinomial y perceptron, estos 2 últimos no se han integrado aun), en función de un método u otro se genera un vector de características diferente (e.g. si es supervisado se requiere la etiqueta de clase), que tendrá una forma semejante a esto .

En cualquier método se pasará antes por 2 puntos clave, entrenar el sistema con las muestras de entrenamiento y finalmente comprobar la clasificación de los apk de los que se quiere saber si son malware o no. Cuantos más datos de entrenamiento se empleen mejor funcionará el sistema (alcanzará un límite en función del algoritmo elegido) sin embargo será más costoso entrenarlo. Este proceso de entrenamiento, en principio, se debe realizar una única vez con todo el conjunto de muestras disponibles sin embargo dado que no se da entrenado ni tamcoco (de momento) la posibilidad de almacenar el "estado" del entrenamiento (e.g. los vectores de pesos en perceptron) se tendrá que entrenar el sistema cada vez que se quiera reconocer una muestra, esto se solucionará en versiones siguientes.

Para ejecutarlo solo teneis que llamar al script No tienes permitido ver los links. Registrarse o Entrar a mi cuenta y él se encarga de realizar todos los procesos que os he comentado tomando los valores por defecto que se indican en No tienes permitido ver los links. Registrarse o Entrar a mi cuenta que son:

PATH_RAW_TRAIN_MALWARE_SAMPLES    = "./Samples/RAW/Train/Malware/"
PATH_RAW_TRAIN_NO_MALWARE_SAMPLES = "./Samples/RAW/Train/NoMalware/"
PATH_RAW_TEST_SAMPLES    		  = "./Samples/RAW/Test/"

MANIFEST                          = "AndroidManifest.xml"
BACKSMALI                         = "classes.dex"
CLASSIFIERS                       = {0:KMeans,1:KernelPerceptron,2:K_nearest_neighbour}
CLASSIFIER                        = 1
VERBOSE                           = True

Os dejo un link de descarga (es mi carpeta tal cual pero con unos 150MB menos en apks,no la iba a subir entera) y el enlace al git (no está actualizado, recomiendo el otro link):

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Comentar también que lleva únicamente un .apk para entrenamiento y test (el mismo además, por lo que siempre acertará), si lo usáis recordad ponerle más muestras en las carpetas que dije anteriormente. Visualización de extracción de caracteristicas, entrenamiento y clasificación:



Y eso es todo, si queréis colaborar solo enviadme un pv2 y vemos que se puede ir haciendo, saludos

Reto resuelto q3rv0, tienes un MP

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
& es un AND a nivel de bits y va preguntando bit by bit si es verdadero , la siguiente instrucción es para moverse al siguiente bit

drive_bitmask >>= 1

¿Moverse al siguiente bit? rara explicación para la operación de desplazamiento.

Lo que conseguimos con ese operador es desplazar los bits de la variable a izquierdas o a derechas dependiendo del sentido indicado. Python ya distingue si tiene que realizar desplazamiento lógico o aritmético distinguiendo si el valor es con signo o sin signo.

Para lo que se suelen utilizar es para realizar multiplicaciones eficientes a nivel del procesador ya que es menos costoso realizar un par de sumas y desplazamientos con un CSA y un Barrel shifter por ejemplo con coste log(n) + C que calcular una multiplicación usando el algoritmo de recodificación por parejas que suele dar buenos resultados con un coste de n/2.

Si te fijas al desplazar n veces un bit a izquierdas estamos multiplicando por 2^n mientras que al desplazar n bits a derechas dividimos por 2^n, esto lo aplican los compiladores en los casos en los que sea más eficiente separar una multiplicación de esta forma que utilizar el operador de multiplicación de la ALU.

Ej:   3 * 36 ( operamos con 7 bits ) -> 36 = 2^5 + 2^2 -> 3*36 = 3*2^5 + 3*2^2
       0000011 * 0100100
       Desplazamos los bits del 3 5 veces a izquierdas -> 1100000
       Desplazamos los bits del 3 2 veces a izquierdas -> 0001100
       Sumamos los resultados -> 1101100 = 108 = 3*36

Con pocos bits como este caso la ganancia es mínima, la multiplicación serían (con el algoritmo de recodificación por parejas, si no, serían 8 ciclos) 4 ciclos (3.5 redondeado al alza) + 1 de inicialización, en total 5 ciclos mientras que con el otro método hemos sacado el resultado con 3 ciclos.

Creo que me he ido del tema pero necesitaba explicarlo xD.

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Gracias 11Sep, eso del contador me ha pasado por que antes programa java y lo usaba mucho jajaja, ni me fije. Thx Bro.
@deni_celine: He mirado tu code por encima y no entiendo esta parte:

if drive_bitmask & 1:

-Saludos-

En java también existe esa forma de iterar:

    public static <E> void testit(E[] vec){
        for(E i : vec){
            System.out.println(i.toString());
        }
    }
    
    public static void main(String args[])
    {
        Integer nVect[] = new Integer[5];
        for(int i=0;i<5;i++) nVect[i] = new Integer(i); 
        testit(nVect);
    }

Un saludo

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
HOLA!!!

Gracias Overflow...

Estoy en desacuerdo con que ese algoritmo es mas veloz que el mio.

Si prestas atencion tu codigo hara aproximadamente 100 call Jump a su funcion, 100 comprobaciones if y ademas sumas.

El mio solo tiene 1 call jump 98 iteraciones menos sumas y sin comprobaciones if.

GRACIAS POR LEER!!!

No dije en ningún momento que fuera más eficiente que el tuyo, es una mejor solución recursiva que la propuesta por deni_celine. Fijate que la solución iterativa es mejor que la solución de la recursión de cola para este reto por el hecho de que hay que llamar n veces a la función para calcular el fib de los n primeros números, mientras que en la tuya no. Sin embargo observa el benchmark para calcular únicamente el fibonacci de un número, probémoslo con un número alto a ver:

#!/usr/bin/env python

import time


def fib_aux(x,y,n):
        return x if n==0 else fib_aux(y,x+y,n-1)
def fib(n):
        return 1 if n<2 else fib_aux(1,1,n-1)

def a():
    b = [1,1]
    for x in range(700): b.append(b[-1]+b[-2])
    return b
    
ttot = 0
for i in range(0,1000):
	it = time.time()
	fib(700)
	et = time.time()
	ttot += et-it
print ttot/1000

ttot = 0
for i in range(0,1000):
	it = time.time()
	a()
	et = time.time()
	ttot += et-it
print ttot/1000

Resultados:
                      · Recursivo : 0.000249599981308s
                      · Iterativo :  0.000144299983978s

Nada mal para ser una solución recursiva dentro de los límites que nos pone la recursión ¿no? (Prueba a hacer el fib de 2000 en el iterativo y en el recursivo verás una gran limitación). Pero si lo probamos para este reto, se ve que la recursiva pierde por mucho mira:

import time


def fib_aux(x,y,n):
        return x if n==0 else fib_aux(y,x+y,n-1)
def fib(n):
        return 1 if n<2 else fib_aux(1,1,n-1)

def a():
    b = [1,1]
    for x in range(100): b.append(b[-1]+b[-2])
    return b
    
ttot = 0
for i in range(0,10000):
	it = time.time()
	t = [fib(n) for n in range(0,100)]
	et = time.time()
	ttot += et-it
print ttot/10000

ttot = 0
for i in range(0,10000):
	it = time.time()
	t = a()
	et = time.time()
	ttot += et-it
print ttot/10000

Resultados:   
                      · Recursivo: 0.0012103000164s
                      · Iterativo : 1.91999912262e-05s

63 veces más rápido el iterativo para este reto. Puedes observar como el coste temporal de tu algoritmo es lineal O(n) mientras que el recursivo en este reto está forzado a ser cuadrático O(n^2) por lo que cuando aumenta la talla (la cantidad de números cuyo fibonacci queremos saber) la diferencia entre los costes se vuelve bastante notable. Como éstas, hay muchas más peculiaridades en los comportamientos de ambos algoritmos y está interesante leer códigos de retos para observarlos.

Un saludo

Enhorabuena 7913... a ver si se anima más gente a participar que en este reto han habido pocos códigos o eso parece .

La solución iterativa es la forma lógica de abordar el problema, tal como lo haría a mano cualquier persona, pero hay otras soluciones muy buenas también.

El código de deni_celine es el típico que usan para aproximar a los nobeles a la recursión, pero no es la solución recursiva más eficiente, es bastante lento como habréis comprobado . Normalmente en los lenguajes compilados el compilador lleva a cabo una tarea de reordenamiento y mejora en la eficiencia del código y lo que suelen hacer algunos compiladores cuando se topan con el algoritmo recursivo de fibonacci es utilizar un acumulador para "plantear" el problema mediante recursión de cola, está claro que el intérprete de python no nos proporciona esto, pero el código del reto por ejemplo sería algo así:

def fib_aux(x,y,n):
	return x if n==0 else fib_aux(y,x+y,n-1)
def fib(n):
	return 1 if n<2 else fib_aux(1,1,n-1)
print [fib(i) for i in range(0,100)]

Un saludo

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Haber si funciona con lo que he editado, esque es una tontería hacer dos for para un proceso y su inversa ademas salen mas lineas...

Tu código era correcto, lo único que no imprimías el resultado en caso de descifrado, pero idéntico a nivel semántico.

El otro código no hace 2 for para un proceso y su inversa, simplemente multiplexa con un condicional la función a realizar y solo se ejecuta uno de los bucles. Muchas veces, una linea o 2 más no importa, incluso puede ayudar a mejorar la eficiencia, aunque no es mucho mira:

Juan:   0.000392249999046s
Sanko: 0.000362740001678s

Además por mi parte veo más lógico saber si primero se va a cifrar o descifrar y luego aplicar la función y no en el mismo bucle de la función realizar n comparaciones siendo n la longitud de la cadena a cifrar (tú estás comprobando por cada caracter si va a ser cifrado o descifrado cada vez que se itera sobre él, esto no es necesario y sobrarían n-1 condicionales ya que el primer resultado es idéntico a los obtenidos después)

En resumidas cuentas, el código de sanko hace 1 condicional y 1 bucle, mientras que el tuyo hace 1 bucle con  n condicionales.

Un saludo manes

Ya que veo que el paper va más del IDE casi que de java te comento que para empezar, uno de los mejores IDE (para mi, está claro, es cuestión de gustos) es Bluej.

Desarrollado inicialmente en Melbourne (Monash University) para uso didáctico, te ahorra un montón de faena, pudiendo instanciar objetos a golpe de click y comprobando métodos y funcionamiento de clases con una interfaz muy cómoda.


No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

[Reto 1] Aprovechar un stack overflow para alterar el registro EIP y ejecutar la función execme. El código es el siguiente:

#include <stdio.h>
void execme()
{
        printf("Ejecutame :)\n");
}

void main(void)
{
        char buffer[64];
        gets(buffer);
}

[Reto 2] Modificar el entry point de un exe (AddressEntryPoint PE).
Os dejo documentación para éste:

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
No tienes permitido ver los links. Registrarse o Entrar a mi cuenta


Pongo las soluciones pero no las miréis antes de tiempo --> No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

El reto consiste en implementar el cifrado RSA con el lenguaje que más gustéis.
Como ya sabréis RSA es un cifrado basado en asimetrías de problemas surgidos en la aritmética modular de números primos, el proceso para cifrado/descifrado es el siguiente:

General:
· Buscamos 2 nº primos medianamente grandes p y q (ponedle un rango entre 1,1000 y será suficiente, no para la práctica ya que la factorización de n, que veremos ahora, será mucho más simple y se podrán encontrar p y q fácilmente.
· Generar n:n=p*q y z:z=(p-1)*(q-1)

Cifrar:
· Generar un e:divisores(e) ∩ divisores(z) = {1}, para los no formales, buscar un e que no tenga ningún divisor en común con z (excepto el 1).
· Ej: Si z=8, coger e = 5. Un truco para esto es coger el inmediatamente inferior a z (o superior), en este caso e = 7 o e = 9
· Ciframos el mensaje: c = (m^e) % n

{c = cifrado,m = mensaje}


Descifrar:
· Buscamos d: e*d % z = 1
· c: c=(c^d) % n

{c = descifrado}


Ejemplo: (hacedlo en decimal, luego si queréis lo usáis para strings y esas cosas que quedan tan bien, además facilitaremos el reto )
{p->3,q->7,n->21,z->12,m->14}
Divisores z = {1,2,3,4,6,12}
Buscamos e : divisores(e) ∩ divisores(z) = {1}, e.g e=5 -> {1,5} ∩ {1,2,3,4,6,12} = {1}, se cumple.
Generar d: 5*d % 12 = 1, sacamos d = 17
Cifrar: c: c=(14^5) % 21 = 14 -- Casualidad que sale el mismo xD
Descifrar c: c=(14^17)%21 = 14 -- Este es el texto inicial.

Os adjunto una posible solución en haskell:

    type Prime = Int
    type PlainText = Char
    type Cipher = Int
   
   
    retN :: Prime -> Prime -> Int
    retN p q = p * q
   
    retZ :: Prime -> Prime -> Int
    retZ p q = (p-1)*(q-1)
   
    retE :: Int -> Int
    retE z = (z-1)
   
    retD :: Int -> Int -> Int -> Int
    retD d e z
             | (e*d) `mod` z == 1 = d
             | otherwise = retD (d+1) e z
             
    cipherCharRsa :: PlainText -> Prime -> Prime -> Cipher
    cipherCharRsa c p q = ((ord c)^(retE (retZ p q))) `mod` (retN p q)
   
    uncipherCharRsa :: Cipher -> Prime -> Prime -> PlainText
    uncipherCharRsa c p q = chr((c^(retD 0 (retE (retZ p q)) (retZ p q))) `mod` (retN p q) + 97)
   
    main :: String -> Prime -> Prime -> String
    main [] p q = ""
    main (x:xs) p q = " " ++ (show (cipherCharRsa x p q))++(main xs p q)

# -*- coding: utf-8 -*-

class Modelo:

    def __init__(self):
        self.divisor = 23
        vac = raw_input("Elige un numero entero entre 0 y 100: ")
        valor = int(vac)
        resultado = self.devolver_resultado(valor)
        print "%d/%d es %d" % (valor, self.divisor, resultado)

    def devolver_resultado(self, numero):
        """Divide el núemro por el divisor y devuelve un entero"""
        resultado = numero//self.divisor
        return resultado

obj = Modelo()

A veces dependiendo del IDE que uses te bailan caracteres ocultos tipo espacios y tabuladores. Normalmente si borras los espacios de la linea hasta que se junte con la linea superior y das un salto de linea para situarla otra vez en el sitio estos problemas se solucionan en IDES con autoindentación.

Un par de trabajos de este año y del pasado, por si os sirven

TCP Reno vs TCP Vegas: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Estructuras de datos lineales Java: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
La mejor carrera que vas a tener es ser autodidacta. Aunque las de galgos no están nada mal.

Lamentablemente en el mundo de hoy el titulo vale mas que el conocimiento

Saludos
Destructor

Correcta errónea, cada vez son más las empresas que prefieren la experiencia en su campo antes que un título teórico, tengo muchos amigos trabajando codo con codo con ingenieros y ellos tan solo han hecho un FP.

Lamentablemente, el título es el título, quien no querria tener a un doctorado (que sabes que trabajará bien) trabajando para ti o contigo

Querido sanko, te tengo que llevar la contraria en algunas partes. Las empresas que prefieren experiencia en su campo antes que un título teórico saben perfectamente que el título teórico refleja capacidad para adaptarse a cualquier situación, aunque seas más listo o más tonto, siempre lo harás mejor que cualquiera con un FP y nada más (no hablo de autodidacta).

Respecto a la autodidáctica, cabe decir que está sobrevalorada (aunque es cierto que ayuda mucho) pero tampoco puedes comparar a alguien que supongamos haya leido un tema por internet y a otro que haya estado hora y media en una clase dando eso únicamente, ni punto de comparación, a la fuerza te entra sí o sí.

Ojo, la universidad tampoco es la panacea, pero te plantean situaciones que te ayudan a madurar, a moldear el cerebro y te muestran cosas que ni en una vida buscando por internet podrías imaginar que existen (situaciones nuevas).

En contra de lo que muchos se piensan, la informática no va de aprender lenguajes, hacer un par de tools que me sirvan y soy el rey del mundo, lleva toda una base detrás mucho más matemática y profunda de lo que os podáis creer algunos, no hablo por ti Sankeras tú ya sabes lo que hay, me aguantas demasiado jaja.

Perdóname si he metido la pata en algo, estoy en uno de esos momentos ya sabes jajaja.

Un saludo 

Coincido con lo que dice overxfl0w13 de que la informatica no solo va aprender lenguajes de programacion, yo estudio primero de ing. informatica y de 10 materias 5 son matematicas puras y otra es fisica, y en las 4 restantes son basadas en matematicas. Un ejemplo podria ser el algoritmo de busqueda de google que usa matrices para posicionar las busquedas, aunque supieran mucho de c++ o el lenguaje que sea si no tuviesen una amplia base matematica no seria posible crear ese algoritmo. Pero como han comentado ya ser autodidacta esta bien, sobre todo si tienes un nivel alto, ya que no aprende lo mismo un autodidacta sin experiencia que uno con un doctorado, yo por ejemplo cuando empece no tenia experiencia en NADA y me costaba muchisimo mas aprender que ahora. Suerte

No se me hubiese ocurrido un ejemplo mejor que el primer algoritmo del pagerank de google -que creo que es lo que planteas- (con el tiempo ha ido actualizándose bastante). Su base son las matrices estocásticas y los vectores de probabilidad y a pesar de que son conceptos simples si no estás acostumbrado nunca sacarás provecho de ellos. Que buenos recuerdos de 1º, aun tengo la práctica por aquí de cuando trabajamos con ese algoritmo .

Respecto al tema de la carrera, como te han dicho por arriba, no te centres en la que más beneficios económicos te reportará, vale más la pena hacer algo que te guste, que hacerlo a disgusto y  cobrar x € más.

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
La mejor carrera que vas a tener es ser autodidacta. Aunque las de galgos no están nada mal.

Lamentablemente en el mundo de hoy el titulo vale mas que el conocimiento

Saludos
Destructor

Correcta errónea, cada vez son más las empresas que prefieren la experiencia en su campo antes que un título teórico, tengo muchos amigos trabajando codo con codo con ingenieros y ellos tan solo han hecho un FP.

Lamentablemente, el título es el título, quien no querria tener a un doctorado (que sabes que trabajará bien) trabajando para ti o contigo

Querido sanko, te tengo que llevar la contraria en algunas partes. Las empresas que prefieren experiencia en su campo antes que un título teórico saben perfectamente que el título teórico refleja capacidad para adaptarse a cualquier situación, aunque seas más listo o más tonto, siempre lo harás mejor que cualquiera con un FP y nada más (no hablo de autodidacta).

Respecto a la autodidáctica, cabe decir que está sobrevalorada (aunque es cierto que ayuda mucho) pero tampoco puedes comparar a alguien que supongamos haya leido un tema por internet y a otro que haya estado hora y media en una clase dando eso únicamente, ni punto de comparación, a la fuerza te entra sí o sí.

Ojo, la universidad tampoco es la panacea, pero te plantean situaciones que te ayudan a madurar, a moldear el cerebro y te muestran cosas que ni en una vida buscando por internet podrías imaginar que existen (situaciones nuevas).

En contra de lo que muchos se piensan, la informática no va de aprender lenguajes, hacer un par de tools que me sirvan y soy el rey del mundo, lleva toda una base detrás mucho más matemática y profunda de lo que os podáis creer algunos, no hablo por ti Sankeras tú ya sabes lo que hay, me aguantas demasiado jaja.

Perdóname si he metido la pata en algo, estoy en uno de esos momentos ya sabes jajaja.

Un saludo 

Buen reto!!, pero va a ganar Sanko, os lo adelanto .

Yo en este no participaré por falta de tiempo, pero ayer me animé a codear el bot en Haskell para dar una alternativa declarativo-funcional y de momento, a pesar de que hay cosas a medias cuenta con funciones para:

-> Enviar mensajes privados
-> Cambiar topic
-> Listar todos los usuarios
-> Whois a usuario
-> Ban a usuario
-> Ping a usuario
-> Get ip de usuario
-> Kick usuario
-> // Todas estas opciones se pueden  aplicar a uno o a varios usuarios
->Conexión con datos personalizables
->Cambiar nombre
->Setear Pass
->Cerrar conexión
->Devolver Hora
->Sistema de logueo
->Encrypt md5
->IA -> sentido del humor implementado con estructura de árbol, tantas ramas como sentidos del humor y tantas hojas como intensidad se le quiera dar a un sentido (jerárquico de izquierda a derecha)

Sin embargo, la E/S es un punto débil de los lenguajes declarativos ya que rompe el principio de la transparencia referencial y se tienen que inventar mecanismos "sucios" para encapsular las funciones que la rompan, por lo que los sockets suelen dar problemas, sin contar con la instalación de paquetes que da más problemas aún por las dependencias.

Os dejo por aquí el código por si os hace ilusión tocarlo en algún momento

IA.hs -> No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Bot.hs -> No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Socket.hs -> No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Commands.hs -> No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Functions.hs -> No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Un saludo

Si estuviese comenzando tendrías toda la razón pero es un proyecto para la universidad y si quieres nota te lo tienes que ganar. No le digo que lo haga ya, si no que tenga en cuenta todo eso a la hora de hacerlo.

$Query= "insert into usuarios (`Nombre`,`Email`,`Clave`,`Nickname`) values( '{$vNombre}', '{$vEmail}', '{$vClave}', '{$vNickname}' )";

Toda esa parafernalia de apóstrofes, "acentos franceses" que llamas tú (a los valencianos y catalanes les ofenderá ), y corchetes son inútiles. Las dobles comillas te permiten concatenar variables sin necesidad de cortar y juntar con un . (evalúan la expresión) y por tanto evitarte tanto '{}' que sobra.

¿La rama de funciones mysql_ no estaba obsoleta? ¿Porqué le recomiendas usar mysql_real_escape_string?. Que use en su defecto mysqli_real_escape_string ¿no? que no lo está.

Respecto a PDO ¿a qué te refieres con consumo?, esto no es una lavadora, tendrá un mayor coste temporal o espacial (consumo espacial o temporal, si,bueno) pero no consumo a secas. Es cierto que tiene un menor rendimiento, pero no es orientado únicamente a mysql y  a la hora de cambiar de tecnología esta homogeneidad se paga. ¿Qué quieres, centrarte en la eficiencia? Usa mysqli, por eso quedó obsoleto mysql.

No me apetece escribir más un saludo 

<?php
include_once("funciones.php");
$vNombre=$_POST['vNombre'];
$vEmail=$_POST['vEmail'];
$vClave=$_POST['vClave'];
$vNickname=$_POST['vNickname'];
$Query=("insert into usuarios (Nombre,Email,Clave,Nickname) values ($vNombre, $vEmail, $vClave, $vNickname)");
print("$Query");
if($guardar=mysql_query($Query,$conexion))
{
    print("Usuario Registrado");
    header('Location: Index.html');
} 
else
{
    print("Error al guardar el usuario");
}
?>

Prueba eso, además filtra los parámetros y usa PDO, corta la ejecución del script si pasa algo raro, desactiva errores de php y lo que se te vaya ocurriendo para protegerte,¿no querrás que te hagan nada no?.

Un saludo