Mensajes

Básicamente para evitar un apagado forzoso del sistema al cerrar ciertos procesos críticos como csrss el taskmgr evita que se cierren los procesos con nombres críticos

[@xivan25]

@xivan25: Task bar != Task Manager...

Llama al ejecutable: "csrss.exe"

Follow up en el tema de escapar de la sandbox:

Código [Seleccionar] Expandir

http://blogbromium.files.wordpress.com/2013/03/blackhat-2013-sandbox-roulette_wp.pdf

+

Código [Seleccionar] Expandir

http://news.softpedia.com/news/Linux-Machines-Exposed-Due-to-VMware-Workstation-Host-Privilege-Escalation-Flaw-400690.shtml

+

Código [Seleccionar] Expandir

http://www.vupen.com/blog/20140725.Advanced_Exploitation_VirtualBox_VM_Escape.php

La única diferencia que soy capaz de ver con mi limitado conocimiento interno de las arquitecturas (al menos entre x86 y ARM) es el tamaño de las instrucciones. En x86 es variable y en ARM no.

La arquitectura que mejor conozco es MIPS, también con tamaño de instrucción fijo (32b), porque la estudiamos en la universidad. Sé que dado el tamaño fijo se puede preveer la posición de la siguiente instrucción con seguridad (salvo que haya algún branch, entonces habría que desechar lo avanzado). Con esto se pueden ir solapando acciones de lectura, reconocimiento de instrucciónes, banco de registros... Por el contrario entiendo que en x86, al tener tamaño variable de instrucción, se debe primero traducir la instrucción y añadir circuitería para variar el IP dependiendo...

Aún con estás deducciones no soy capaz de ver la problemática de la que hablas...

El problema es que calculas la suma antes de leer el resultado.
Las variables num1 y num2 obtienen valor en las lineas: cin >> num1; y cin >> num2;. Y tú haces la suma antes.

La forma correcta de hacerlo es así:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <stdlib.h>


using namespace std;

int main ()
{

     int num1;
     int num2;

     int suma;


     cout << "Introduce el primer numero\n"<<endl;
     cin >> num1;

     cout << "Introduce el segundo numero\n"<<endl;
     cin >> num2;

     suma = num1 + num2;

     cout << "El resultados es: " << suma << "\n" <<endl; //al invocar suma a mi no me sale por ejempo 2+2 me dice que es 0 :/

     system ("pause");
     return 0;
}

Pensé que querías proteger desde otro proceso

Código (vb) [Seleccionar] Expandir

Private Declare Sub GetMem4 Lib "MSVBVM60" (ByVal Addr As Long, RetVal As Long)

Código (vb) [Seleccionar] Expandir

Option Explicit

'KERNEL32
Private Declare Function OpenProcess Lib "KERNEL32" (ByVal dwDA As Long, ByVal bIH As Integer, ByVal dwPID As Long) As Long
Private Declare Sub CloseHandle Lib "KERNEL32" (ByVal hObject As Long)
Private Declare Function ReadProcessMemory Lib "KERNEL32" (ByVal hProcess As Long, ByVal lpBaseAddress As Any, lpBuffer As Any, ByVal nSize As Long, lpNumberOfBytesWritten As Long) As Long
'NTDLL
Private Declare Function NtQueryInformationProcess Lib "NTDLL" (ByVal ProcessHandle As Long, ByVal InformationClass As Long, ByRef ProcessInformation As Any, ByVal ProcessInformationLength As Long, ByRef ReturnLength As Any) As Long
   
Private Const PROCESS_VM_READ           As Long = &H10
Private Const PROCESS_QUERY_INFORMATION As Long = &H400

Private Const ProcessBasicInformation = 0

Private Type PROCESS_BASIC_INFORMATION
   ExitStatus                      As Long
   PebBaseAddress                  As Long
   AffinityMask                    As Long
   BasePriority                    As Long
   UniqueProcessId                 As Long
   InheritedFromUniqueProcessId    As Long
End Type

Private Const MY_REL_POS    As Long = &H1C7E
Private Const MY_SIZE       As Long = &HF

Sub Main()
   Dim lPID    As Long
   Dim hProc   As Long
   Dim bvBuf() As Byte
   
   Do
       lPID = Val(InputBox("PID a proteger?"))
   Loop Until lPID > 0
   
   hProc = OpenProcess(PROCESS_QUERY_INFORMATION + PROCESS_VM_READ, False, lPID)
   
   If hProc Then
       ReDim bvBuf(0 To MY_SIZE)
       If ReadProcessMemory(hProc, GetBaseAddr(hProc) + MY_REL_POS, bvBuf(0), MY_SIZE, ByVal 0&) Then
           Debug.Print Hex$(bvBuf(0))
       End If
       Call CloseHandle(hProc)
   End If
End Sub

Private Function GetBaseAddr(ByVal hProc As Long) As Long
   Dim PBI     As PROCESS_BASIC_INFORMATION
   
   Call NtQueryInformationProcess(hProc, ProcessBasicInformation, PBI, Len(PBI), Len(PBI))
   If PBI.PebBaseAddress Then
       Call ReadProcessMemory(hProc, PBI.PebBaseAddress + 8, GetBaseAddr, 4, ByVal 0)
   End If
End Function

La obtención del BaseAddr del proceso no funcionará si el proceso es de 64bits.

 

Aquí tienes un proyecto para desarrollar scripting bajo Android:

Código [Seleccionar] Expandir

https://code.google.com/p/android-scripting/

Lo mejor sería hacer la suma de comprobación del bloque de memoria crítica. Bastaría con leer la memoria del proceso a proteger con ReadProcessMemory() y tras realizar el checksum comparar.
En caso de que hubiese discrepancia y pretendieses reparar la zona de memoria lo adecuado sería suspender el hilo de ejecución con SuspendThread() y después de WriteProcessMemory() resumirlo con ResumeThread().

En caso de que sólo quieras proteger la memoria del proceso durante la ejecución puedes meter un breakpoint de escritura en ese zona de memoria.