Posts by Sophie

2015-09-22 at 10:26 PM UTC in plz help with python debugger

Sophie Pedophile Tech Support

WWLN (what would Lanny do)

Who knows? The Lan works in mysterious ways.

2015-09-22 at 10:13 PM UTC in I just stumbled upon this old ironic post from kreepkay

Sophie Pedophile Tech Support

HA! I bet someone saved dem pics.

2015-09-22 at 9:29 PM UTC in plz help with python debugger

Sophie Pedophile Tech Support

None reproducible in my case. Also, i think PROCESS_ALL_ACCESS should be defined in the ctypes module. Do you have the required privilege to attach your debugger to the process you're trying to target?

This is what the debugger scripts look like for me.


# My debugger
from ctypes import *
from my_debugger_defines import *

import sys
import time
kernel32 = windll.kernel32

class debugger():

    def __init__(self):
        self.h_process       =     None
        self.pid             =     None
        self.debugger_active =     False
        self.h_thread        =     None
        self.context         =     None
        self.breakpoints     =     {}
        self.first_breakpoint=     True
        self.hardware_breakpoints = {}
        
        # Here let's determine and store
        # the default page size for the system
        # determine the system page size.
        system_info = SYSTEM_INFO()
        kernel32.GetSystemInfo(byref(system_info))
        self.page_size = system_info.dwPageSize
        
        # TODO: test
        self.guarded_pages      = []
        self.memory_breakpoints = {}
        
    def load(self,path_to_exe):
        
        # dwCreation flag determines how to create the process
        # set creation_flags = CREATE_NEW_CONSOLE if you want
        # to see the calculator GUI
        creation_flags = DEBUG_PROCESS
    
        # instantiate the structs
        startupinfo         = STARTUPINFO()
        process_information = PROCESS_INFORMATION()
        
        # The following two options allow the started process
        # to be shown as a separate window. This also illustrates
        # how different settings in the STARTUPINFO struct can affect
        # the debuggee.
        startupinfo.dwFlags     = 0x1
        startupinfo.wShowWindow = 0x0
        
        # We then initialize the cb variable in the STARTUPINFO struct
        # which is just the size of the struct itself
        startupinfo.cb = sizeof(startupinfo)
        
        if kernel32.CreateProcessA(path_to_exe,
                                   None,
                                   None,
                                   None,
                                   None,
                                   creation_flags,
                                   None,
                                   None,
                                   byref(startupinfo),
                                   byref(process_information)):
            
            print "
[*] We have successfully launched the process!"
            print "
[*] The Process ID I have is: %d" % \
                         process_information.dwProcessId
            self.pid = process_information.dwProcessId
            self.h_process = self.open_process(self,process_information.dwProcessId)
            self.debugger_active = True
        else:    
            print "
[*] Error with error code %d." % kernel32.GetLastError()

    def open_process(self,pid):
        
        # PROCESS_ALL_ACCESS = 0x0x001F0FFF
        h_process = kernel32.OpenProcess(PROCESS_ALL_ACCESS,False,pid)
        
        return h_process
    
    def attach(self,pid):
        
        self.h_process = self.open_process(pid)
        
        # We attempt to attach to the process
        # if this fails we exit the call
        if kernel32.DebugActiveProcess(pid):
            self.debugger_active = True
            self.pid             = int(pid)
                                  
        else:
            print "
[*] Unable to attach to the process."
            
    def run(self):
        
        # Now we have to poll the debuggee for
        # debugging events          
        while self.debugger_active == True:
            self.get_debug_event()
    
    def get_debug_event(self):
        
        debug_event    = DEBUG_EVENT()
        continue_status = DBG_CONTINUE
        
        if kernel32.WaitForDebugEvent(byref(debug_event),100):
            # grab various information with regards to the current exception.
            self.h_thread          = self.open_thread(debug_event.dwThreadId)
            self.context           = self.get_thread_context(h_thread=self.h_thread)
            self.debug_event       = debug_event
            
                      
            print "Event Code: %d Thread ID: %d" % \
                (debug_event.dwDebugEventCode,debug_event.dwThreadId)
            
            if debug_event.dwDebugEventCode == EXCEPTION_DEBUG_EVENT:
                self.exception = debug_event.u.Exception.ExceptionRecord.ExceptionCode
                self.exception_address = debug_event.u.Exception.ExceptionRecord.ExceptionAddress
                
                # call the internal handler for the exception event that just occured.
                if self.exception == EXCEPTION_ACCESS_VIOLATION:
                    print "Access Violation Detected."
                elif self.exception == EXCEPTION_BREAKPOINT:
                    continue_status = self.exception_handler_breakpoint()
                elif self.exception == EXCEPTION_GUARD_PAGE:
                    print "Guard Page Access Detected."
                elif self.exception == EXCEPTION_SINGLE_STEP:
                    self.exception_handler_single_step()
                
            kernel32.ContinueDebugEvent(debug_event.dwProcessId, debug_event.dwThreadId, continue_status)

            
    def detach(self):
        
        if kernel32.DebugActiveProcessStop(self.pid):
            print "
[*] Finished debugging. Exiting..."
            return True
        else:
            print "There was an error"
            return False
    
    def open_thread (self, thread_id):
        
        h_thread = kernel32.OpenThread(THREAD_ALL_ACCESS, None, thread_id)
        
        if h_thread is not None:
            return h_thread
        else:
            print "
[*] Could not obtain a valid thread handle."
            return False
        
    def enumerate_threads(self):
              
        thread_entry     = THREADENTRY32()
        thread_list      = []
        snapshot         = kernel32.CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, self.pid)
        
        if snapshot is not None:
        
            # You have to set the size of the struct
            # or the call will fail
            thread_entry.dwSize = sizeof(thread_entry)

            success = kernel32.Thread32First(snapshot, byref(thread_entry))

            while success:
                if thread_entry.th32OwnerProcessID == self.pid:
                    thread_list.append(thread_entry.th32ThreadID)
    
                success = kernel32.Thread32Next(snapshot, byref(thread_entry))
            
            # No need to explain this call, it closes handles
            # so that we don't leak them.
            kernel32.CloseHandle(snapshot)
            return thread_list
        else:
            return False
        
    def get_thread_context (self, thread_id=None,h_thread=None):
        
        context = CONTEXT()
        context.ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS
        
        # Obtain a handle to the thread
        if h_thread is None:
            self.h_thread = self.open_thread(thread_id)
                        
        if kernel32.GetThreadContext(self.h_thread, byref(context)):
            
            return context
        else:
            return False
    
    def read_process_memory(self,address,length):
        
        data         = ""
        read_buf     = create_string_buffer(length)
        count        = c_ulong(0)
        
        
        kernel32.ReadProcessMemory(self.h_process, address, read_buf, 5, byref(count))
        data    = read_buf.raw
        
        return data
    
    
    def write_process_memory(self,address,data):
        
        count  = c_ulong(0)
        length = len(data)
        
        c_data = c_char_p(data[count.value:])

        if not kernel32.WriteProcessMemory(self.h_process, address, c_data, length, byref(count)):
            return False
        else:
            return True
    
    def bp_set(self,address):
        print "
[*] Setting breakpoint at: 0x%08x" % address
        if not self.breakpoints.has_key(address):

            # store the original byte
            old_protect = c_ulong(0)
            kernel32.VirtualProtectEx(self.h_process, address, 1, PAGE_EXECUTE_READWRITE, byref(old_protect))
            
            original_byte = self.read_process_memory(address, 1)
            if original_byte != False:
                
                # write the INT3 opcode
                if self.write_process_memory(address, "\xCC"):
                    
                    # register the breakpoint in our internal list
                    self.breakpoints[address] = (original_byte)
                    return True
            else:
                return False

    
    def exception_handler_breakpoint(self):
        print "
[*] Exception address: 0x%08x" % self.exception_address
        # check if the breakpoint is one that we set
        if not self.breakpoints.has_key(self.exception_address):
          
                # if it is the first Windows driven breakpoint
                # then let's just continue on
                if self.first_breakpoint == True:
                   self.first_breakpoint = False
                   print "
[*] Hit the first breakpoint."
                   return DBG_CONTINUE
              
        else:
            print "
[*] Hit user defined breakpoint."
            # this is where we handle the breakpoints we set
            # first put the original byte back
            self.write_process_memory(self.exception_address, self.breakpoints[self.exception_address])

            # obtain a fresh context record, reset EIP back to the
            # original byte and then set the thread's context record
            # with the new EIP value
            self.context = self.get_thread_context(h_thread=self.h_thread)
            self.context.Eip -= 1
            
            kernel32.SetThreadContext(self.h_thread,byref(self.context))
            
            continue_status = DBG_CONTINUE


        return continue_status

    def func_resolve(self,dll,function):
        
        handle  = kernel32.GetModuleHandleA(dll)
        address = kernel32.GetProcAddress(handle, function)
        
        kernel32.CloseHandle(handle)

        return address
    
    def bp_set_hw(self, address, length, condition):
        
        # Check for a valid length value
        if length not in (1, 2, 4):
            return False
        else:
            length -= 1
            
        # Check for a valid condition
        if condition not in (HW_ACCESS, HW_EXECUTE, HW_WRITE):
            return False
        
        # Check for available slots
        if not self.hardware_breakpoints.has_key(0):
            available = 0
        elif not self.hardware_breakpoints.has_key(1):
            available = 1
        elif not self.hardware_breakpoints.has_key(2):
            available = 2
        elif not self.hardware_breakpoints.has_key(3):
            available = 3
        else:
            return False

        # We want to set the debug register in every thread
        for thread_id in self.enumerate_threads():
            context = self.get_thread_context(thread_id=thread_id)

            # Enable the appropriate flag in the DR7
            # register to set the breakpoint
            context.Dr7 |= 1 << (available * 2)

            # Save the address of the breakpoint in the
            # free register that we found
            if   available == 0: context.Dr0 = address
            elif available == 1: context.Dr1 = address
            elif available == 2: context.Dr2 = address
            elif available == 3: context.Dr3 = address

            # Set the breakpoint condition
            context.Dr7 |= condition << ((available * 4) + 16)

            # Set the length
            context.Dr7 |= length << ((available * 4) + 18)

            # Set this threads context with the debug registers
            # set
            h_thread = self.open_thread(thread_id)
            kernel32.SetThreadContext(h_thread,byref(context))

        # update the internal hardware breakpoint array at the used slot index.
        self.hardware_breakpoints[available] = (address,length,condition)

        return True
    
    def exception_handler_single_step(self):
        print "
[*] Exception address: 0x%08x" % self.exception_address
        # Comment from PyDbg:
        # determine if this single step event occured in reaction to a hardware breakpoint and grab the hit breakpoint.
        # according to the Intel docs, we should be able to check for the BS flag in Dr6. but it appears that windows
        # isn't properly propogating that flag down to us.
        if self.context.Dr6 & 0x1 and self.hardware_breakpoints.has_key(0):
            slot = 0

        elif self.context.Dr6 & 0x2 and self.hardware_breakpoints.has_key(1):
            slot = 0
        elif self.context.Dr6 & 0x4 and self.hardware_breakpoints.has_key(2):
            slot = 0
        elif self.context.Dr6 & 0x8 and self.hardware_breakpoints.has_key(3):
            slot = 0
        else:
            # This wasn't an INT1 generated by a hw breakpoint
            continue_status = DBG_EXCEPTION_NOT_HANDLED

        # Now let's remove the breakpoint from the list
        if self.bp_del_hw(slot):
            continue_status = DBG_CONTINUE

        print "
[*] Hardware breakpoint removed."
        return continue_status
    
    def bp_del_hw(self,slot):
        
        # Disable the breakpoint for all active threads
        for thread_id in self.enumerate_threads():

            context = self.get_thread_context(thread_id=thread_id)
            
            # Reset the flags to remove the breakpoint
            context.Dr7 &= ~(1 << (slot * 2))

            # Zero out the address
            if   slot == 0:
                context.Dr0 = 0x00000000
            elif slot == 1:
                context.Dr1 = 0x00000000
            elif slot == 2:
                context.Dr2 = 0x00000000
            elif slot == 3:
                context.Dr3 = 0x00000000

            # Remove the condition flag
            context.Dr7 &= ~(3 << ((slot * 4) + 16))

            # Remove the length flag
            context.Dr7 &= ~(3 << ((slot * 4) + 18))

            # Reset the thread's context with the breakpoint removed
            h_thread = self.open_thread(thread_id)
            kernel32.SetThreadContext(h_thread,byref(context))
            
        # remove the breakpoint from the internal list.
        del self.hardware_breakpoints[slot]

        return True

    #TODO: test
    def bp_set_mem (self, address, size):
        
        mbi = MEMORY_BASIC_INFORMATION()
        
        # Attempt to discover the base address of the memory page
        if kernel32.VirtualQueryEx(self.h_process, address, byref(mbi), sizeof(mbi)) < sizeof(mbi):
            return False

    
        current_page = mbi.BaseAddress
    
        # We will set the permissions on all pages that are
        # affected by our memory breakpoint.
        while current_page <= address + size:
        
            # Add the page to the list, this will
            # differentiate our guarded pages from those
            # that were set by the OS or the debuggee process
            self.guarded_pages.append(current_page)
            
            old_protection = c_ulong(0)
            if not kernel32.VirtualProtectEx(self.h_process, current_page, size, mbi.Protect | PAGE_GUARD, byref(old_protection)):
                return False
        
            # Increase our range by the size of the
            # default system memory page size
            current_page += self.page_size
    
        # Add the memory breakpoint to our global list
        self.memory_breakpoints[address] = (address, size, mbi)
    
        return True


# My debugger defines
from ctypes import *

# Let's map the Microsoft types to ctypes for clarity
BYTE      = c_ubyte
WORD      = c_ushort
DWORD     = c_ulong
LPBYTE    = POINTER(c_ubyte)
LPTSTR    = POINTER(c_char)
HANDLE    = c_void_p
PVOID     = c_void_p
LPVOID    = c_void_p
UINT_PTR  = c_ulong
SIZE_T    = c_ulong

# Constants
DEBUG_PROCESS         = 0x00000001
CREATE_NEW_CONSOLE    = 0x00000010
PROCESS_ALL_ACCESS    = 0x001F0FFF
INFINITE              = 0xFFFFFFFF
DBG_CONTINUE          = 0x00010002


# Debug event constants
EXCEPTION_DEBUG_EVENT      =    0x1
CREATE_THREAD_DEBUG_EVENT  =    0x2
CREATE_PROCESS_DEBUG_EVENT =    0x3
EXIT_THREAD_DEBUG_EVENT    =    0x4
EXIT_PROCESS_DEBUG_EVENT   =    0x5
LOAD_DLL_DEBUG_EVENT       =    0x6
UNLOAD_DLL_DEBUG_EVENT     =    0x7
OUTPUT_DEBUG_STRING_EVENT  =    0x8
RIP_EVENT                  =    0x9

# debug exception codes.
EXCEPTION_ACCESS_VIOLATION     = 0xC0000005
EXCEPTION_BREAKPOINT           = 0x80000003
EXCEPTION_GUARD_PAGE           = 0x80000001
EXCEPTION_SINGLE_STEP          = 0x80000004


# Thread constants for CreateToolhelp32Snapshot()
TH32CS_SNAPHEAPLIST = 0x00000001
TH32CS_SNAPPROCESS  = 0x00000002
TH32CS_SNAPTHREAD   = 0x00000004
TH32CS_SNAPMODULE   = 0x00000008
TH32CS_INHERIT      = 0x80000000
TH32CS_SNAPALL      = (TH32CS_SNAPHEAPLIST | TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD | TH32CS_SNAPMODULE)
THREAD_ALL_ACCESS   = 0x001F03FF

# Context flags for GetThreadContext()
CONTEXT_FULL                   = 0x00010007
CONTEXT_DEBUG_REGISTERS        = 0x00010010

# Memory permissions
PAGE_EXECUTE_READWRITE         = 0x00000040

# Hardware breakpoint conditions
HW_ACCESS                      = 0x00000003
HW_EXECUTE                     = 0x00000000
HW_WRITE                       = 0x00000001

# Memory page permissions, used by VirtualProtect()
PAGE_NOACCESS                  = 0x00000001
PAGE_READONLY                  = 0x00000002
PAGE_READWRITE                 = 0x00000004
PAGE_WRITECOPY                 = 0x00000008
PAGE_EXECUTE                   = 0x00000010
PAGE_EXECUTE_READ              = 0x00000020
PAGE_EXECUTE_READWRITE         = 0x00000040
PAGE_EXECUTE_WRITECOPY         = 0x00000080
PAGE_GUARD                     = 0x00000100
PAGE_NOCACHE                   = 0x00000200
PAGE_WRITECOMBINE              = 0x00000400


# Structures for CreateProcessA() function
# STARTUPINFO describes how to spawn the process
class STARTUPINFO(Structure):
    _fields_ = [
        ("cb",            DWORD),        
        ("lpReserved",    LPTSTR),
        ("lpDesktop",     LPTSTR),  
        ("lpTitle",       LPTSTR),
        ("dwX",           DWORD),
        ("dwY",           DWORD),
        ("dwXSize",       DWORD),
        ("dwYSize",       DWORD),
        ("dwXCountChars", DWORD),
        ("dwYCountChars", DWORD),
        ("dwFillAttribute",DWORD),
        ("dwFlags",       DWORD),
        ("wShowWindow",   WORD),
        ("cbReserved2",   WORD),
        ("lpReserved2",   LPBYTE),
        ("hStdInput",     HANDLE),
        ("hStdOutput",    HANDLE),
        ("hStdError",     HANDLE),
        ]

# PROCESS_INFORMATION receives its information
# after the target process has been successfully
# started.
class PROCESS_INFORMATION(Structure):
    _fields_ = [
        ("hProcess",    HANDLE),
        ("hThread",     HANDLE),
        ("dwProcessId", DWORD),
        ("dwThreadId",  DWORD),
        ]

# When the dwDebugEventCode is evaluated
class EXCEPTION_RECORD(Structure):
    pass
    
EXCEPTION_RECORD._fields_ = [
        ("ExceptionCode",        DWORD),
        ("ExceptionFlags",       DWORD),
        ("ExceptionRecord",      POINTER(EXCEPTION_RECORD)),
        ("ExceptionAddress",     PVOID),
        ("NumberParameters",     DWORD),
        ("ExceptionInformation", UINT_PTR * 15),
        ]

class _EXCEPTION_RECORD(Structure):
    _fields_ = [
        ("ExceptionCode",        DWORD),
        ("ExceptionFlags",       DWORD),
        ("ExceptionRecord",      POINTER(EXCEPTION_RECORD)),
        ("ExceptionAddress",     PVOID),
        ("NumberParameters",     DWORD),
        ("ExceptionInformation", UINT_PTR * 15),
        ]

# Exceptions
class EXCEPTION_DEBUG_INFO(Structure):
    _fields_ = [
        ("ExceptionRecord",    EXCEPTION_RECORD),
        ("dwFirstChance",      DWORD),
        ]

# it populates this union appropriately
class DEBUG_EVENT_UNION(Union):
    _fields_ = [
        ("Exception",         EXCEPTION_DEBUG_INFO),
#        ("CreateThread",      CREATE_THREAD_DEBUG_INFO),
#        ("CreateProcessInfo", CREATE_PROCESS_DEBUG_INFO),
#        ("ExitThread",        EXIT_THREAD_DEBUG_INFO),
#        ("ExitProcess",       EXIT_PROCESS_DEBUG_INFO),
#        ("LoadDll",           LOAD_DLL_DEBUG_INFO),
#        ("UnloadDll",         UNLOAD_DLL_DEBUG_INFO),
#        ("DebugString",       OUTPUT_DEBUG_STRING_INFO),
#        ("RipInfo",           RIP_INFO),
        ]  

# DEBUG_EVENT describes a debugging event
# that the debugger has trapped
class DEBUG_EVENT(Structure):
    _fields_ = [
        ("dwDebugEventCode", DWORD),
        ("dwProcessId",      DWORD),
        ("dwThreadId",       DWORD),
        ("u",                DEBUG_EVENT_UNION),
        ]

# Used by the CONTEXT structure
class FLOATING_SAVE_AREA(Structure):
   _fields_ = [
  
        ("ControlWord", DWORD),
        ("StatusWord", DWORD),
        ("TagWord", DWORD),
        ("ErrorOffset", DWORD),
        ("ErrorSelector", DWORD),
        ("DataOffset", DWORD),
        ("DataSelector", DWORD),
        ("RegisterArea", BYTE * 80),
        ("Cr0NpxState", DWORD),
]

# The CONTEXT structure which holds all of the
# register values after a GetThreadContext() call
class CONTEXT(Structure):
    _fields_ = [
    
        ("ContextFlags", DWORD),
        ("Dr0", DWORD),
        ("Dr1", DWORD),
        ("Dr2", DWORD),
        ("Dr3", DWORD),
        ("Dr6", DWORD),
        ("Dr7", DWORD),
        ("FloatSave", FLOATING_SAVE_AREA),
        ("SegGs", DWORD),
        ("SegFs", DWORD),
        ("SegEs", DWORD),
        ("SegDs", DWORD),
        ("Edi", DWORD),
        ("Esi", DWORD),
        ("Ebx", DWORD),
        ("Edx", DWORD),
        ("Ecx", DWORD),
        ("Eax", DWORD),
        ("Ebp", DWORD),
        ("Eip", DWORD),
        ("SegCs", DWORD),
        ("EFlags", DWORD),
        ("Esp", DWORD),
        ("SegSs", DWORD),
        ("ExtendedRegisters", BYTE * 512),
]

# THREADENTRY32 contains information about a thread
# we use this for enumerating all of the system threads

class THREADENTRY32(Structure):
    _fields_ = [
        ("dwSize",             DWORD),
        ("cntUsage",           DWORD),
        ("th32ThreadID",       DWORD),
        ("th32OwnerProcessID", DWORD),
        ("tpBasePri",          DWORD),
        ("tpDeltaPri",         DWORD),
        ("dwFlags",            DWORD),
    ]

# Supporting struct for the SYSTEM_INFO_UNION union
class PROC_STRUCT(Structure):
    _fields_ = [
        ("wProcessorArchitecture",    WORD),
        ("wReserved",                 WORD),
]


# Supporting union for the SYSTEM_INFO struct
class SYSTEM_INFO_UNION(Union):
    _fields_ = [
        ("dwOemId",    DWORD),
        ("sProcStruc", PROC_STRUCT),
]
# SYSTEM_INFO structure is populated when a call to
# kernel32.GetSystemInfo() is made. We use the dwPageSize
# member for size calculations when setting memory breakpoints
class SYSTEM_INFO(Structure):
    _fields_ = [
        ("uSysInfo", SYSTEM_INFO_UNION),
        ("dwPageSize", DWORD),
        ("lpMinimumApplicationAddress", LPVOID),
        ("lpMaximumApplicationAddress", LPVOID),
        ("dwActiveProcessorMask", DWORD),
        ("dwNumberOfProcessors", DWORD),
        ("dwProcessorType", DWORD),
        ("dwAllocationGranularity", DWORD),
        ("wProcessorLevel", WORD),
        ("wProcessorRevision", WORD),
]

# MEMORY_BASIC_INFORMATION contains information about a
# particular region of memory. A call to kernel32.VirtualQuery()
# populates this structure.
class MEMORY_BASIC_INFORMATION(Structure):
    _fields_ = [
        ("BaseAddress", PVOID),
        ("AllocationBase", PVOID),
        ("AllocationProtect", DWORD),
        ("RegionSize", SIZE_T),
        ("State", DWORD),
        ("Protect", DWORD),
        ("Type", DWORD),
]

If i run these with your sample code:



#my_test.py
# code I run to test the debugger and its components
import my_debugger

debugger = my_debugger.debugger()

#debugger.load("C:\\WINDOWS\\system32\\calc.exe")
pid = raw_input("Enter the PID of the process to attach to: ")

debugger.attach(int(pid))

debugger.detach()

And i input a PID i selected from a running process from my task manager list. It prints that debugging has been successful.

I have something that may interest you though as a side note, if you run your code like this from an elevated command prompt.



#my_test.py
# code I run to test the debugger and its components
import my_debugger
from win32com.client import GetObject
import sys,  os

debugger = my_debugger.debugger()

debugger.load("C:\\WINDOWS\\system32\\calc.exe")

Wmi = GetObject('winmgmts:')
processes = Wmi.InstancesOf('Win32_Process')
# Get process
calculator = Wmi.ExecQuery('select * from Win32_Process where Name="calc.exe"')
# Grab its PID
pid =calculator[0].Properties_('ProcessId').Value

debugger.attach(int(pid))

debugger.detach()

It's going to grab the PID of calc.exe on it's own if it's a win32 process that is.

2015-09-22 at 7:15 PM UTC in Do you day dream?

Sophie Pedophile Tech Support

Lovely imagery in your words, you should make a movie/write a book.

2015-09-22 at 7:01 PM UTC in Your mom is so homeless

Sophie Pedophile Tech Support

Thank you friend. Unfortunately I have to give them right back cuz, ya know, I gotsa to give props to you for giving props to me when I didn't deserve the props.

I'll tell you what, we split the props 50-50, how does that sound to you?

2015-09-22 at 6:40 PM UTC in Your mom is so homeless

Sophie Pedophile Tech Support

Welp, I guess I don't get any props, which really sucks, because I'm totally almost out of props. Now I'm going to have to go to the fucking dirty ass prop shop downtown and associate myself with those lowlife fucks just to get a few more props under my belt. Sucks man.

Well, because i feel for you, here are some props anyway.

2015-09-22 at 6:24 PM UTC in Your mom is so homeless

Sophie Pedophile Tech Support

Props if you get the joke without having to google Chandrasekhar limit.

2015-09-22 at 5:42 PM UTC in Do you day dream?

Sophie Pedophile Tech Support

I fantasize about shooting up a shopping mall while this song plays full blast on my headphones.

I imagine myself emptying the magazine of a fully automatic assault rifle into a crowd of people in slow motion, the casings falling to the ground with that distinctive noise they make when they hit concrete after being ejected.

It would be a symphony of death.

2015-09-22 at 5:35 PM UTC in Morality and Law

Sophie Pedophile Tech Support

Then let's just follow the Ten Commandments and abolish all other laws; call it good. XD

It would be better than the current system that's for sure.

2015-09-22 at 5:32 PM UTC in Your mom is so homeless

Sophie Pedophile Tech Support

Your mom is so fat, her mass exceeds the Chandrasekhar limit.

2015-09-22 at 5:23 PM UTC in Morality and Law

Sophie Pedophile Tech Support

There is no universally preferable behavior. I don't think there's any one thing that most of a specific country would agree upon, let alone the entire globe. There are still tribes that would disagree murder or cannibalism or baby-mutilation are unethical. Ethics and morals, to me, will always be very relative. That being said, laws that enforce a specific group's agreed upon code-of-ethics clearly serves a purpose, modern times or otherwise. It's not necessarily fair to everyone because there will likely always be the minority who disagree with a particular law, such as meth-addicts would prefer meth to be legal though most of the surrounding populous would disagree. There are some more black and white issues and some a bit more gray, but these issues are always subject to change (see: slavery, cannabis, age of consent, etc).

Of course there's universally preferable behavior. It doesn't mean however every one acts according to it. Consider the following.

A thief may want to steal your wallet but he doesn't want everyone to be a thief, because he'd lose his profits that way. Therefore everyone agrees that not stealing is the universally preferable behavior. If you take the universally preferable behaviors you can derive a universal standard of ethics.

2015-09-22 at 5:11 PM UTC in The Giving Tree by Shel Silverstein

Sophie Pedophile Tech Support

Sounds depressing as fuck.

2015-09-22 at 5:07 PM UTC in Which niggas stay fit?

Sophie Pedophile Tech Support

I try to eat healthy, and commute manually if possible. Other than that i don't even lift breh. When the end of the world comes rolling round i'll just try to join a group, i'm pretty useful, i can make explosives and rig electric things.

2015-09-22 at 5:06 PM UTC in ATTN: Sophey

Sophie Pedophile Tech Support

1. Subpoena, court, judge, jury, crime, idk man.

2015-09-22 at 5 PM UTC in Fedoras: Or how I learned to start worrying and became a self-loathing STEM fag

Sophie Pedophile Tech Support

Well there's a distinction here I think. The two mindsets I resent are "computer science(programming) is a way to make lots of money" and "If you're not in a STEM field then you don't matter". The former really drains the quality from the community that made me love it in the first place, the mirth and lust for knowledge that characterizes "hacker" (I could rant about that term but w/e) culture. I guess it's an inevitable consequence of professionalization but when people are only here to collect a paycheck it stops being about the fun weekend projects, subverting expectations, doing something really novel, especially in an economic clementine that encourages the most conservative, derivative steps towards what we basically already have (consider the number of "X killer" startups. If you define yourself as trying to fill someone else's market niche better then you've resigned yourself, categorically, to non-novel work). In practice it also undermines the academic pursuit as well, when you're just looking to make a buck the only possible payout for disseminating a novel discovery is a meager PR boost, whereas in the days of yore (although this is a tradition that persists in the infosec world to some extend) the reputation you earn from doing something new and interesting was worth far more than a possible market edge because people fucking cared about the opinions of their peers and advancing the state of the art rather than making a buck.

And the other side, STEM supremacy, so far as I can tell, comes from a mere ignorance of the humanities. It's really astounding to see, and you can probably do this yourself with people you know, to ask someone who dismisses philosophy as a field about why they feel that way. Within three sentences you'll hear a philosophical claim that has been argued and understood in the western philosophical tradition for hundreds of years, which has nothing to do with any STEM field, and yet will be presented as some knockdown argument against philosophy as a field. People who buy into this anti-humanities rhetoric are so ignorant of what they oppose they don't even realize their argument for their own position are straight out of historical works in the humanities themselves.

So yeah, I mean programming is hard no doubt, I don't mean to trivialize the efforts of the novice, but it's this tiny corner of the universe, a formal system that's important only because we can make circuits to emulate it quickly (a historical accident). If you're going to devote your time to it I think it's worth asking if you want to learn it because it's interesting or if it's a mere means to an end.

Being the guilty-capitalistic cunt that I am I've read probably every essay Paul Graham has written and I remember something he said (although I can't remember the particular essay because I have a block against his bullshit) that I really agree with although I didn't fully understand at the time. He said that to be a good hacker(read: programmer) you had to enjoy the practice of actually programming. He went on to say that you didn't have to enjoy it so much that it's the your first priority all the time, because even the most devoted programmer will prefer to fuck some hot chick or chill on a Hawaiian beach or something at some point, but the important point was that if you had to choose between watching TV or some other mundane thing you can do every day for a quick hit of pleasure and programming, you would choose programming. And I tend to agree with that, I think that's a good litmus test, if you can't enjoy the material act of plying your trade more than something that's constantly available to you then you're probably better off finding something you like more to spend your life on.

Now you personally, Soph, I have high hopes for you. You're on here, you're on stack overflow, you're asking questions and stumbling your way through real projects when you could be watching something or taking drugs or whatever. God knows I cave to the desire to get drunk, eat icecream, and watch shitty slice of life anime sometimes. Programming as a trade may be secondary to your interests in information security but you have something you're willing to invest the time in getting good at and that's a fucking asset like no other. For whatever reason this field is pretty democratic, people are generally willing to share their knowledge with those who are willing to put in the time, so the blocker is caring enough to put in the time and so far you've done pretty damn well at that. I certainly don't think I'm owed any special respect for whatever level of skill I have in this field but it's not people like you who I'm criticizing here, it's people who are drawn to this field because it's a "good job" and who don't have the spine to say "fuck it" and go get a degree in history or something.

Do you remember the poster ond? He had a lot of alts because he got banned a lot. Fascinating person, in a lot of ways, but there was this period where he was basically teaching me programming. This was back when I was in highschool and like my first year of college, I had muddled around with some BS stuff here and there but wasn't anywhere close to a professional level while he had landed a dev job. We had this little project we both worked on, I'd do some stuff, he'd make it better, I'd ask him why and he'd explain. He worked with me for a month or so, we talked on IRC pretty often, and in that time I learned an incredible amount, but the most important thing I learned by far (and which to this day I think many developers don't know) is the self confidence to dive into problems or source code I don't understand with the conviction that I'll come out the other side with enough understanding to do what I want to. To this day I owe my success in academia to him, and my career to a large extend. He was the person who showed me how to either hack it or recognize inevitable defeat in the face of any odds. His instruction showed me that I was cut out for this, something I wan't sure of before.

Anyway I guess my point, besides dickriding one of the most hated niggers in this community, is that there's a certain constitution you need to be good at this particular thing. If you're not that's fine, there are many other things humans can do, many of which are far more important to us as a species, but to find out if this particular corner of the world is the place for you, you have to charge headlong at the hardest problems you find interesting. It doesn't much matter if you succeed or fail, the important question is if when you get to the other side, when you realize if you can solve your problem or not, if you're ready to go another round, to jump back into the fray and get you ass beat again, if you can enjoy the thrill of the chase regardless of where it lands you then you're made of the same stuff that every world class computer scientist, programmer, and hacker ever was.

An inspirational post for sure, as to the vote of confidence, thank you sir i try me hardest, i consider myself fortunate that i have the intellect to gather the resources that will make a difference in my particular case, if i consider the book i'm working with Black Hat Python, at first i thought: Dang, this is going to be hard as fuck, then i thought fuck it, i'll just read it from cover to cover and do all the projects and even if my understanding only increases by 5% i will still have come out more knowledgeable. Turns out, the book actually helps me a lot, not only in learning programming but computer science in general and of course it makes me more proficient at infosec in the meantime since everything is oriented towards using your programming skills to that end. Mmm, i can't wait until i get to the end where we'll be making a trojan framework, because malware is fucking win on a stick with awesome sprinkled ontop At heart i'm just a lazy nigger though and sometimes i have a hard time motivating myself, but then i think to myself, what if in time, i'll become really proficient. I'll be pretty damn proud of myself and maybe get some stars on github, lol. Seems a silly thing to desire, but some external recognition of my improvements as a programmer will make me feel good and motivate me to get even better.

I thought my idea for gcat was pretty good, make a downloader, start at boot and disable task manager. https://github.com/NullArray/gcat/bl.../downloader.py

It's pretty much a copypasta hackjob but pls notice me senpais. Kek.

As you said, i love how the infosec community is really a community if you put in the work, which i intend to do.

Also, i remember ond, i did not know he was a programmer, pretty cool how he helped you out like that.

2015-09-22 at 4:19 PM UTC in Morality and Law

Sophie Pedophile Tech Support

Why? How would that make your morality not relative?

Because ethics aren't subjective when based on the principle of universally preferable behavior.

2015-09-22 at 4:16 PM UTC in WHO'S THAT POKÃ‰MON!?

Sophie Pedophile Tech Support

Or what? :p

We must battle to the death.

2015-09-22 at 4:14 PM UTC in more starter fluid trip reports

Sophie Pedophile Tech Support

If you're gonna' huff ether at least get the clean, pure variety noobs.

2015-09-22 at 4:11 PM UTC in Are flies jedis?

Sophie Pedophile Tech Support

Long answer: Yes.

Short answer: No.

2015-09-22 at 4:03 PM UTC in Do you go outside?

Sophie Pedophile Tech Support

Well, outside is where the lolis are, which is a good a reason as any.

User Controls

Navigation