<?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 Sandeep Vishwakarma on Medium]]></title>
        <description><![CDATA[Stories by Sandeep Vishwakarma on Medium]]></description>
        <link>https://medium.com/@sandeepvi?source=rss-1125fd6b489d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Lq6SJU4bpuCz3jBigHGIvw.jpeg</url>
            <title>Stories by Sandeep Vishwakarma on Medium</title>
            <link>https://medium.com/@sandeepvi?source=rss-1125fd6b489d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 11:07:56 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sandeepvi/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[Testing PHP2Shell in Local PHP Lab]]></title>
            <link>https://infosecwriteups.com/testing-php2shell-in-local-php-lab-15496b51972a?source=rss-1125fd6b489d------2</link>
            <guid isPermaLink="false">https://medium.com/p/15496b51972a</guid>
            <category><![CDATA[php2shell]]></category>
            <category><![CDATA[rce]]></category>
            <category><![CDATA[vulnerability]]></category>
            <category><![CDATA[exploit]]></category>
            <dc:creator><![CDATA[Sandeep Vishwakarma]]></dc:creator>
            <pubDate>Sat, 24 Oct 2026 11:53:31 GMT</pubDate>
            <atom:updated>2026-10-24T17:34:52.482Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*arbymQDZqBk7uDhLkkL3bg.png" /></figure><p>Greetings, I’m Sandy. I built a small PHP lab to understand what a version-based PHP2Shell check can show. My target ran on 127.0.0.1 inside a dedicated local environment. I also read the public research and PHP advisories about CVE-2026–109618 and CVE-2026–109619. The central lesson is that a version finding is a useful starting point for investigation, while exploitability depends on the runtime and request lifecycle.</p><h3>Why PHP2Shell drew attention</h3><p>The name PHP2Shell is used for research and tooling around two critical PHP issues whose impact can include remote code execution. The PHP advisories describe separate but related classes of unsafe runtime state: one involving out-of-memory handling during request processing, and another involving request-owned state that can remain reachable after a request ends. In either case, the important idea is that PHP workers process requests through several initialization and cleanup phases. If an interruption leaves internal state inconsistent, later cleanup or a later request can encounter state it should no longer use.</p><h3>Two vulnerability themes</h3><h3>Out of memory and request cleanup</h3><p>CVE-2026–109618 concerns PHP handling an out-of-memory condition while request data is in a partially initialized state. The official advisory explains that the request shutdown path can then encounter invalid state. It confirms remote code execution in affected Apache mod_php circumstances. The advisory discusses FPM separately: a child process exits when request startup fails, which changes that particular path; other conditions may still be relevant, but the deployment model must be assessed on its own.</p><h3>Stale state across requests</h3><p>CVE-2026–109619 concerns request-owned state that remains referenced by a persistent worker after the request memory is released. A later operation can consume that stale state before normal initialization resets it. The advisory describes a producer-and-consumer lifecycle: one operation leaves state behind, and a later operation on the same worker reaches it. This is why application routes, configuration, and which requests land on the same worker matter to the assessment.</p><h3>Where multipart and session handling fit</h3><p>Multipart uploads are relevant because PHP processes parts of a request before the application script begins. Session upload progress can also interact with session and decoder state during this early phase. The research article discusses this timing alongside session handling, serialization and cleanup behaviour, and other application-specific state. These are not interchangeable recipes: a path that depends on a particular application, extension, or SAPI should not be described as universal exposure.</p><p>The Substack report labels five scenarios as chains A through E. Here is a brief conceptual summary so readers can distinguish them. These are the report author’s findings, not results from my version-check lab. The descriptions below omit payloads and execution steps; each scenario depends on specific application, configuration, or runtime conditions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xh8a1NyFNdgiQcmR7NF7zQ.png" /></figure><h3>Chain A Session data and file inclusion</h3><p>The report describes a combination of PHP session handling, upload-related data, and an application file-inclusion weakness. The important qualifier is that the application-level file-inclusion condition is part of the scenario; this is not a claim that every PHP upload endpoint provides code execution.</p><h3>Chain B Deserialization cleanup and re-entry</h3><p>This scenario concerns memory lifetime during object deserialization and cleanup. The report says that nested parsing triggered during object destruction can encounter data that has already been released. Whether an application can reach such a state depends on its deserialization behaviour and other runtime conditions.</p><h3>Chain C Session format mismatch</h3><p>The article discusses applications that use different session serialization formats in different parts of one server. Data written under one format may be interpreted differently by another handler. This is a configuration-specific interaction and should be checked against the actual session settings and application boundaries.</p><h3>Chain D Out-of-memory handling in Apache mod_php</h3><p>This path focuses on memory exhaustion during multipart request processing and the request shutdown behaviour of Apache mod_php. PHP’s official advisory confirms the underlying out-of-memory corruption issue and identifies mod_php as a confirmed susceptible configuration. The advisory also cautions that PHP-FPM has different worker behaviour, so the same startup-failure sequence cannot simply be assumed there.</p><h3>Chain E Worker state and PHP-FPM</h3><p>The report separately describes state left by one request being reached during later session upload-progress handling in a PHP-FPM worker. This is a cross-request lifecycle scenario. PHP’s stale-state advisory explains why producer and consumer operations must line up on the same worker; exact applicability depends on the application and configuration.</p><p>The source article reports exploit outcomes for its own lab. I have not reproduced those chains. PHP’s advisories are the primary references for the vulnerability descriptions, confirmed scope, affected branches, and fixes. This overview is intentionally not an exploit guide.</p><p>The safest way to read a report that presents multiple chains is to separate confirmed advisory impact from the conditions required for each path. In particular, Apache mod_php and PHP-FPM have different worker and startup behaviour. A statement about one SAPI does not automatically apply to another, and a candidate path is not the same as a demonstrated exploit for every deployment.</p><h3>What I checked in my local lab</h3><p>My exercise was much narrower than the source-level research. I wanted to compare the endpoint’s disclosed version with the runtime inside the container. The first screenshot is from a run where the endpoint reported PHP 8.4.27. After I changed the lab image and restarted the container, the next run reported PHP 8.4.26.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*9kFByuumTZxiruYCNfrjDw.png" /><figcaption><em>Earlier run: the local endpoint disclosed PHP 8.4.27, which the scanner compared with its fixed-version threshold.</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*7ISLdFdbtqPeS56BybiYmg.png" /><figcaption><em>Later run: the endpoint disclosed PHP 8.4.26, below the scanner’s PHP 8.4.27 threshold.</em></figcaption></figure><p>A version banner is useful for triage, but it may be hidden, altered, or different from the vendor package version. Operating-system vendors can also backport security fixes while keeping a different version string. For systems you administer, check the package vendor’s security notice and installed package details along with the HTTP response.</p><h3>Confirming the container version</h3><p>I checked PHP from inside the running container and then used the passive fingerprinting mode against the loopback endpoint:</p><blockquote>docker exec p2s-target php -r “echo PHP_VERSION, PHP_EOL;”</blockquote><blockquote>python3 detect.py <a href="http://127.0.0.1:18110/index.php">http://127.0.0.1:18110/index.php</a></blockquote><p>The container returned 8.4.26, and the scanner classified that version as below the PHP 8.4.27 threshold. This confirms which version string the lab exposed and which runtime the container reported. It does not test whether a vulnerable code path was reachable, whether a particular SAPI condition was met, or whether code execution succeeded.</p><h3>What the PoC screenshot shows</h3><p>I kept the cropped screenshot from the PHP2Shell tool because it is part of my lab record. Its visible output identifies PHP 8.4.26 as a pre-fix runtime and shows the tool beginning stage 1 of 8.</p><blockquote><strong>Exploit : </strong><a href="https://github.com/spade-kk/php2shell-exploit"><strong>https://github.com/spade-kk/php2shell-exploit</strong></a></blockquote><blockquote><strong>Exploit : </strong><a href="https://github.com/ikow/php2shell-poc"><strong>https://github.com/ikow/php2shell-poc</strong></a></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*azlobkQ1M-KN_5Nmwsyeuw.png" /><figcaption><em>The screenshot shows the tool’s version verdict and the start of its first stage. It contains no completed exploit result or command output.</em></figcaption></figure><p>A startup message is not proof of RCE. The screenshot does not show a completed run, a shell, or a command result. My article therefore treats it as a tool-start observation and keeps the lab evidence separate from the exploit claims in external research.</p><h3>Fixed versions and mitigation</h3><p>PHP lists 8.2.35, 8.3.36, 8.4.27, and 8.5.12 as the fixed releases for the affected maintained branches. Updating to a release containing the fixes is the complete remediation. After updating, restart PHP workers and verify the package and active runtime so old processes are not left serving requests.</p><p>The advisories discuss temporary configuration measures for specific paths, such as disabling upload progress when it is not needed. They also make clear that such measures do not cover every stale-state or out-of-memory path and are not a replacement for upgrading. Memory and request-size controls can reduce risk, but administrators should use the official guidance for their SAPI and platform rather than copy a setting without considering its operational impact.</p><p>During a controlled audit, review PHP, web-server, reverse-proxy, and application logs for repeated warnings, deprecations, fatal errors, and failures around upload, shutdown, or extension code. Logs help identify configuration and lifecycle issues, but a quiet log is not proof of safety. The advisory recommends a wider configuration and application-flow review as part of mitigation.</p><h3>Keeping the exercise safe and repeatable</h3><p>For a classroom or personal exercise, keep the intentionally vulnerable service bound to loopback, use a disposable container, and avoid exposing it to a public network. Confirm the container version before scanning, use only the passive check shown here, and stop the lab when finished. Test systems you own or have clear permission to assess.</p><p>For a production system, use the fixed package supplied by your platform, restart the relevant workers, and verify the active version. A passive scan can help prioritise a review, but it cannot replace package verification or the platform vendor’s remediation advice.</p><h3>Takeaway</h3><p>The research around PHP2Shell covers more than a version number: request startup and shutdown, memory exhaustion, persistent worker state, multipart uploads, session handling, application-specific conditions, and differences between server APIs all affect the analysis. My screenshots demonstrate only a local version comparison. PHP 8.4.27 was reported as patched by the scanner, while 8.4.26 was reported as below its threshold. The cropped PoC image shows the tool starting, not a successful exploit. Use the official advisories to patch and assess your actual deployment.</p><h3>References</h3><p>· <a href="https://github.com/php/php-src/security/advisories/GHSA-w8hw-w9fx-j79w">PHP advisory for CVE-2026–109618: RCE via OOM corruption</a></p><p>· <a href="https://github.com/php/php-src/security/advisories/GHSA-6wmf-4rv5-p3rp">PHP advisory for CVE-2026–109619: RCE via stale global state</a></p><p>· <a href="https://www.php.net/archive/2026.php#2026-10-21-5">PHP news archive for the fixed release announcement</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=15496b51972a" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/testing-php2shell-in-local-php-lab-15496b51972a">Testing PHP2Shell in Local PHP Lab</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CVE-2026-9082: Testing Drupal’s Critical PostgreSQL SQL Injection]]></title>
            <link>https://osintteam.blog/cve-2026-9082-testing-drupals-critical-postgresql-sql-injection-4203ac023890?source=rss-1125fd6b489d------2</link>
            <guid isPermaLink="false">https://medium.com/p/4203ac023890</guid>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[cve]]></category>
            <category><![CDATA[drupal]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[sql-injection]]></category>
            <dc:creator><![CDATA[Sandeep Vishwakarma]]></dc:creator>
            <pubDate>Sat, 29 Aug 2026 23:00:27 GMT</pubDate>
            <atom:updated>2026-08-29T23:17:49.445Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v8AUTkPy1OGD0kQ6VjlBxA.png" /><figcaption>CVE-2026–9082</figcaption></figure><p>Greetings, fellow hackers! I’m Sandy, an Information Security Consultant and bug-bounty hunter. In this write-up, I want to share what I learned while testing CVE-2026–9082 in a controlled Drupal lab.</p><p>Some vulnerabilities begin with a complicated exploit chain. This one begins with something much smaller: an array key becoming part of a database placeholder name.</p><p>That detail caught my attention because this is not the usual SQL injection caused by a developer directly joining user input into a query. The problem sits deeper, inside Drupal Core’s PostgreSQL query handling. An anonymous request can influence the way a placeholder name is built, and that small implementation detail can open the door to database access.</p><p>Drupal disclosed the issue on May 20, 2026. The GitHub Advisory Database scores it at 9.8, and CISA later placed it in the Known Exploited Vulnerabilities catalog. In simple terms: if a Drupal site uses PostgreSQL and has not been patched, this deserves immediate attention.</p><h3>CVE-2026–9082 : Key Details</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/635/1*Cbvkm3fY6G5VsX2ZT4WTow.png" /></figure><h3>Where the vulnerability lives</h3><p>Drupal uses a database abstraction layer so the same application code can work with different database engines. Normally, that layer also helps keep user input away from raw SQL syntax.</p><p>Here, the problem appears in the PostgreSQL-specific Entity Query condition handler. A user-controlled PHP array key can become part of a named SQL placeholder. That distinction matters. A prepared statement can safely bind a value, but it cannot protect query structure that was already built from untrusted input.</p><h3>Following the input to the query</h3><p>I found the easiest way to understand the bug was to follow the input from the HTTP request to the final query:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/580/1*bgkqrZ0WnYEIEP7ewU4rOw.png" /></figure><p>That was the important takeaway for me: prepared statements are not magic. Values may be bound safely while a placeholder name, identifier, or another structural part of the query is still unsafe.</p><h3>Why I consider this bug dangerous</h3><blockquote>· Anonymous attack surface: a malicious user may not need a Drupal account.</blockquote><blockquote>· Remote reachability: exploitation can be attempted over HTTP against an exposed site.</blockquote><blockquote>· No victim interaction: no document opening or approval prompt is required.</blockquote><blockquote>· Sensitive database access: user records, password hashes, configuration data, private content, and business information may be exposed.</blockquote><blockquote>· Escalation potential: database write access can enable account takeover or persistent application changes; some configurations may permit broader compromise.</blockquote><blockquote>· Confirmed operational risk: CISA added the CVE to its Known Exploited Vulnerabilities catalog.</blockquote><h3>Affected and fixed Drupal versions</h3><p>The official Drupal advisory identifies the following vulnerable ranges. The SQL injection path specifically affects sites using PostgreSQL.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/633/1*C5-rEuOWSmqJ3EeOSwVDdQ.png" /></figure><p>Drupal 8, Drupal 9, and several listed branches are end-of-life. Emergency patches can reduce immediate exposure, but organizations should migrate to a supported release rather than treating an exceptional patch as a long-term solution.</p><h3>Lab validation: from a small signal to real impact</h3><p>For lab validation, I referred to the public PoC published by 7h30th3r0n3. The repository demonstrates the JSON:API-to-PostgreSQL path and credits michaelmaturi with discovering the original vulnerability. I recommend reading the source before running any security tool; it makes the request flow much easier to understand.</p><h3>The turning point: the response changed</h3><p>I tested only against an environment where I had permission. First, I used the boolean-based check and compared the true and false responses. One condition returned five records; the other returned none. That was the small signal I was looking for. The request was not simply producing an error — it was changing the query logic.</p><p>At that stage, the issue moved from ‘possibly vulnerable’ to confirmed in my lab. The next controlled test showed the real impact: data belonging to Drupal’s administrator account could be recovered from the database.</p><p>I have blurred the target, endpoint inventory, username, email address, and password hash in the screenshots. Even test data can reveal more than expected once an image is published.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ztj91lSFKDI4YX2SWxTXYA.png" /><figcaption><em>Authorized lab validation of the vulnerable JSON:API path. Sensitive target and endpoint details are blurred.</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HOFivgsCpfbtEs9YGxZzxg.png" /><figcaption><em>Demonstration of the potential data-exposure impact. Extracted credentials and personal information are blurred.</em></figcaption></figure><h3>How to check your environment</h3><p>Before doing anything complicated, check two basics: the Drupal Core version and the database driver. If the site is not using PostgreSQL, this particular injection path does not apply. If it is using PostgreSQL, compare the installed release with the patched-version table above.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/550/1*mRdsj8H-ceXTQR5ptVpXAQ.png" /></figure><p>A PostgreSQL-backed Drupal configuration normally uses the pgsql driver. Do not paste the complete settings.php file into a ticket or public forum because it may contain credentials and secrets.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/751/1*L8-fayblWP_aAc0xHQoSrA.png" /></figure><h3>Remediation</h3><p>The correct fix is to update Drupal Core. Do not depend on a WAF rule as the permanent answer. For many Composer-managed sites, the update looks like this, although the package list must match the project’s composer.json:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/599/1*hYmcOg7f3uTdZIZwjaYOYA.png" /></figure><p>I would still take a verified backup and test the change in staging, but I would not leave this patch waiting for the next monthly cycle. After deployment, confirm the version again and rebuild Drupal’s cache.</p><p>A WAF may buy some time by blocking familiar payload patterns. It should be treated as temporary risk reduction, not remediation. Different encodings and request-normalization behavior can make a signature easy to miss.</p><h3>Patch, then investigate</h3><p>There is one more step that is easy to overlook: patching does not tell you whether somebody already exploited the site. If a vulnerable instance was reachable from the internet, I would review:</p><p>· Requests to JSON and JSON:API endpoints containing unusual nested filter structures.</p><p>· PostgreSQL errors, timing anomalies, and unexpected query patterns.</p><p>· New or modified administrator accounts, roles, and permissions.</p><p>· Unexpected changes to Drupal modules, themes, PHP files, and scheduled tasks.</p><p>· Outbound connections from web and database servers.</p><p>· Unexpected access to configuration files, credential stores, and sensitive tables.</p><p>Preserve relevant web-server, Drupal, WAF, database, authentication, and operating-system logs. If compromise is suspected, rotate database credentials, privileged passwords, API tokens, and other secrets accessible to the application, and follow the organization’s incident-response process.</p><h3>Defensive hardening</h3><p>· Grant the Drupal database account only the permissions the application needs.</p><p>· Do not expose PostgreSQL directly to the public internet.</p><p>· Centralize application, proxy, database, and authentication logs.</p><p>· Alert on abnormal JSON:API activity and repeated database errors.</p><p>· Remove unused modules and disable unnecessary public endpoints.</p><p>· Keep Drupal Core and Composer dependencies on supported branches.</p><p>· Maintain tested backups and a documented incident-response playbook.</p><h3>What developers should learn</h3><p>The bug is a useful reminder that saying ‘we use prepared statements’ is not the end of a SQL-injection review. Prepared statements protect values when the query structure stays fixed. They do not automatically protect table names, column names, operators, sorting instructions, query fragments, or placeholder names.</p><p>If user input can affect one of those structural pieces, use a strict allowlist or map it to a fixed internal value. This matters even more in shared framework code: one unsafe query-building helper can quietly expose many endpoints.</p><h3>Final thoughts</h3><p>CVE-2026–9082 is serious because the attacker can be anonymous, the vulnerable path is reachable over the network, and the impact reaches the database. Public PoCs and confirmed exploitation make the patching window even smaller.</p><p>If you manage Drupal with PostgreSQL, check the version today, apply the official update, and look through the logs instead of assuming the patch is the end of the story.</p><p>I hope this practical breakdown helps you understand the issue and validate your own authorized lab. If you found it useful, feel free to share it with another Drupal administrator or security researcher. Happy hacking — and always test responsibly.</p><h3>References</h3><p><a href="https://www.drupal.org/sa-core-2026-004">Drupal Security Advisory SA-CORE-2026–004</a></p><p><a href="https://github.com/advisories/GHSA-ghwc-95x2-682j">GitHub Advisory Database: GHSA-ghwc-95x2–682j</a></p><p><a href="https://www.cisa.gov/known-exploited-vulnerabilities-catalog">CISA Known Exploited Vulnerabilities Catalog</a></p><p><a href="https://github.com/7h30th3r0n3/CVE-2026-9082-Drupal-PoC">PoC repository by 7h30th3r0n3</a></p><p><a href="https://www.slcyber.io/research/keys-to-the-kingdom-anonymous-sql-injection-in-drupal-core-cve-2026-9082">Technical analysis by Searchlight Cyber</a></p><p><a href="https://www.cyber.gc.ca/en/alerts-advisories/drupal-security-advisory-av26-492">Canadian Centre for Cyber Security advisory</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4203ac023890" width="1" height="1" alt=""><hr><p><a href="https://osintteam.blog/cve-2026-9082-testing-drupals-critical-postgresql-sql-injection-4203ac023890">CVE-2026-9082: Testing Drupal’s Critical PostgreSQL SQL Injection</a> was originally published in <a href="https://osintteam.blog/">OSINT Team</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Step-by-Step Beginner’s Guide to Windows Thick-Client Penetration Testing with VWA]]></title>
            <link>https://osintteam.blog/windows-thick-client-penetration-testing-f5ad6233bf35?source=rss-1125fd6b489d------2</link>
            <guid isPermaLink="false">https://medium.com/p/f5ad6233bf35</guid>
            <category><![CDATA[ethical-hacking]]></category>
            <category><![CDATA[windows-security]]></category>
            <category><![CDATA[application-security]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Sandeep Vishwakarma]]></dc:creator>
            <pubDate>Sat, 22 Aug 2026 21:18:31 GMT</pubDate>
            <atom:updated>2026-08-22T21:21:03.391Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YIRWOZmoR_By9gKCjkaFfg.png" /><figcaption><em>An isolated Windows laboratory for learning thick-client penetration testing with VWA.</em></figcaption></figure><p>Greetings, fellow hackers! I’m Sandy, a Infosec Consultant and bug-bounty hunter.</p><p>Most of us enter application security through websites. We open Burp Suite, capture a request and start changing parameters. That workflow feels familiar after a while. Then somebody gives us a Windows desktop application and asks us to test it.</p><p>There may be no URL to paste into a browser. Instead, we find EXE files, DLLs, Windows services, registry entries, named pipes and configuration files scattered across the machine. The application may also keep important business logic — or even credentials — on the endpoint. My first question was simple: where do I even begin?</p><p>The answer was to stop looking for one magic tool. Thick-client testing becomes much easier when we watch what the program actually does. Which files does it search for? Which account runs the process? Can an ordinary user modify something later trusted by an administrator-level service? What leaves the machine over the network?</p><p>For this walkthrough I’m using <strong>Viparva</strong>, the intentionally Vulnerable Windows Application (VWA) published by DarkRelay Security Labs. It is a practice target made specifically for Windows thick-client testing. I have written the guide so beginners can follow the reasoning, not just copy commands.</p><h3>Table of contents</h3><ol><li>What is a thick client?</li></ol><p>2. Why thick-client penetration testing matters</p><p>3. What we will test in VWA</p><p>4. Building a safe Windows laboratory</p><p>5. Installing VWA and recording a baseline</p><p>6. A repeatable thick-client testing methodology</p><p>7. Exercise 1: EXE hijacking</p><p>8. Exercise 2: DLL hijacking</p><p>9. Exercise 3: insecure local permissions</p><p>10. Exercise 4: information leakage in a binary</p><p>11. Exercise 5: insecure client-server communication</p><p>12. Exercise 6: symlink attack analysis</p><p>13. What I would test next</p><p>14. Turning evidence into a professional finding</p><p>15. Remediation checklist for thick-client developers</p><p>16. What I learned from this lab</p><h3>1. What is a thick client?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*YOylZpod8kYmSPNTU054hQ.png" /><figcaption><em>The four areas I map before testing a Windows thick client.</em></figcaption></figure><p>A thick client — also called a fat client — is software installed on an endpoint that performs a meaningful amount of processing locally. Examples include accounting tools, trading terminals, VPN clients, database administration software, healthcare applications and enterprise launchers.</p><p>A thin web client relies heavily on a remote server. A thick client may contain business rules, parsing logic, cryptographic material, database drivers and update mechanisms on the user’s machine. It can still communicate with APIs or backend services, but the local endpoint is a major part of its security boundary.</p><p>That creates a useful mental model. During testing, study four layers:</p><p>· <strong>Files:</strong> executables, DLLs, configuration files, logs, temporary files and update packages.</p><p>· <strong>Operating-system objects:</strong> services, processes, registry keys, COM objects, scheduled tasks, named pipes and access-control lists.</p><p>· <strong>Runtime state:</strong> command-line arguments, environment variables, loaded modules, handles and process memory.</p><p>· <strong>Communication:</strong> TCP/UDP traffic, TLS validation, custom protocols, local IPC and backend authorization.</p><p>The client machine must be treated as hostile from a defensive point of view. A user can often inspect files, debug their own process and change data they are permitted to write. Security decisions that matter to the business should therefore be enforced again on a trusted server.</p><h3>2. Why thick-client penetration testing matters</h3><p>Desktop software frequently runs with more access than a normal web page. An updater may run as SYSTEM; a service may run as an administrator; a launcher may read sensitive local files; and a client may connect directly to a database. A small design error can cross a privilege boundary.</p><p>Common issues include:</p><blockquote>· A privileged process loads an executable or DLL from a directory writable by ordinary users.</blockquote><blockquote>· A Windows service uses an unquoted path containing spaces.</blockquote><blockquote>· Credentials, API keys or encryption keys are embedded in a binary or left in memory.</blockquote><blockquote>· Sensitive traffic is transmitted in clear text or TLS certificates are not validated correctly.</blockquote><blockquote>· A named pipe allows unauthorized users to read, write or impersonate clients.</blockquote><blockquote>· Local files or registry keys have overly permissive access-control entries.</blockquote><blockquote>· The client trusts values that the server should independently authorize.</blockquote><blockquote>· An unsigned installer or update can be replaced without reliable publisher verification.</blockquote><p>The impact can range from information disclosure and tampering to persistence or local privilege escalation.</p><h3>3. What we will test in VWA</h3><p>The VWA repository identifies the following intentional weaknesses:</p><p>· DLL hijacking</p><p>· EXE hijacking</p><p>· symlink attacks</p><p>· Image File Execution Options (IFEO) injection</p><p>· unquoted service paths</p><p>· man-in-the-middle attacks</p><p>· weak named pipes</p><p>· weak memory protection</p><p>· stack buffer overflow</p><p>· absence of digital signatures</p><p>· COM hijacking</p><p>· process injection</p><p>The repository supplies separate 32-bit and 64-bit MSI installers and lists Windows 10 x64, Windows Server 2016 and Windows Server 2019 x64 as tested platforms. Because this is training software and operating-system behavior changes over time, reproduce the lab on a supported disposable image and document the exact build you use.</p><p>We will fully walk through discovery for several issues. For dangerous categories such as memory corruption and process injection, we will focus on identification, evidence and safe validation rather than weaponized payload development.</p><h3>4. Building a safe Windows laboratory</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*CUxM2cDpKELTK_owVjBiDg.png" /><figcaption><em>A safe VWA setup keeps the vulnerable VM separated from production systems and the internet.</em></figcaption></figure><h3>What you need</h3><p>· A Windows 10 x64 virtual machine</p><p>· VMware Workstation, VirtualBox, Hyper-V or another hypervisor</p><p>· One administrator account for installation and monitoring</p><p>· One standard user account for permission-boundary testing</p><p>· The VWA installer from the official GitHub repository</p><p>· Microsoft Sysinternals Process Monitor, Process Explorer, Autoruns, TCPView and Sigcheck</p><p>· Regshot for registry comparison</p><p>· Wireshark for packet capture</p><p>· x64dbg for basic binary inspection</p><p>· Optional: a Windows Attack Surface Analyzer and a safe compiler for a message-box DLL</p><p>DarkRelay’s README also mentions Immunity Debugger, Echo Mirage, Google Project Zero’s symbolic-link testing tools and MinGW. Download tools only from their official project pages and verify hashes or signatures where they are available.</p><h3>Isolate the machine</h3><p>Create a new VM and choose <strong>host-only networking</strong> if you do not need downloads inside it. If internet access is temporarily necessary, use NAT, download the required material and then disconnect the virtual adapter. Do not use bridged mode. Disable shared folders, shared clipboard and drag-and-drop while testing.</p><p>Take a snapshot named something like:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*4M7x7W8I1rCe7u5GrERK5w.png" /></figure><p>Keep a second snapshot after installing your tools but before installing VWA:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*TqVaGsudqvqiceNtRDQIww.png" /></figure><p>Snapshots matter because some exercises intentionally modify directories or registry data. A clean rollback is more dependable than trying to remember every change.</p><h3>Create two security contexts</h3><p>Use the administrator account to install VWA and run diagnostic tools that require elevation. Use the standard account to test whether a low-privileged user can alter an object consumed by a privileged process.</p><p>This distinction is essential. Finding that an administrator can replace an administrator-owned file is not a privilege escalation. A convincing finding shows that a less-trusted principal controls an input used by a more-trusted process.</p><h3>5. Installing VWA and recording a baseline</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*FwhXAmZ7YgRVIprjSWFdJA.png" /><figcaption><em>Example VWA installation screen for the isolated Windows laboratory.</em></figcaption></figure><p>Download the correct MSI from the <a href="https://github.com/DarkRelay-Security-Labs/VWA">official VWA repository</a>. For our 64-bit VM, use ViparvaInstaller_x64.msi. The project instructs users to install the MSI as Administrator.</p><p><strong>Before installation:</strong></p><p>17. Start Regshot and take the first registry snapshot.</p><p>18. Start Process Monitor as Administrator.</p><p>19. Clear existing events with <strong>Ctrl+X</strong>.</p><p>20. Enable file-system, registry, process/thread and network activity.</p><p>21. Begin capture.</p><p>22. Install VWA as Administrator.</p><p>23. Stop capture immediately after installation.</p><p>24. Save the trace as a native PML file.</p><p>25. Take the second Regshot snapshot and compare it with the first.</p><p>Now record the installation inventory:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FlKRqM1y3CmsOG9W1K0SOQ.png" /></figure><p>Inspect permissions:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xk7niugK9WZbrXTr01Y3HQ.png" /></figure><p>List related processes and services:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*inKA3dgo-sJ4C-b3xXEXJw.png" /></figure><p>Do not rush into exploitation. Your baseline explains what the installer created, which identity runs each component and which paths deserve attention.</p><h3>6. A repeatable thick-client testing methodology</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*gxyOuNKGnUDIMZZaGNtBmw.png" /><figcaption><em>The workflow I repeat for each VWA module.</em></figcaption></figure><p>For every feature, use the same loop:</p><p>26. <strong>Observe:</strong> Capture file, registry, process and network activity while exercising one function.</p><p>27. <strong>Reduce noise:</strong> Filter by the target process, path or operation.</p><p>28. <strong>Identify a trust boundary:</strong> Ask which lower-privileged identity controls an input used by a higher-privileged component.</p><p>29. <strong>Form a hypothesis:</strong> For example, “Beeper.exe requests a missing file from a user-writable directory.”</p><p>30. <strong>Validate safely:</strong> Use Calculator, a text file or a message box as a visible proof.</p><p>31. <strong>Reproduce:</strong> Revert the VM and repeat the smallest sequence needed.</p><p>32. <strong>Document:</strong> Preserve commands, timestamps, screenshots, logs, permissions and process identity.</p><p>33. <strong>Remediate and retest:</strong> Confirm that the fix removes the dangerous condition rather than only blocking your first payload.</p><p>Procmon produces thousands of events, so filtering is a core skill. Useful filters include:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mOkDFnizXG92RD7rfM9p0A.png" /></figure><p>Start broad enough to understand behavior, then narrow the trace. An event that says NAME NOT FOUND is only a clue. It becomes a vulnerability when the search reaches a location an attacker can write and the resulting code executes across a meaningful privilege boundary.</p><h3>7. Exercise 1: EXE hijacking</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*aMWCI0qkUNauOZahypQyyg.png" /><figcaption><em>Example process trace showing the missing PipeClient.exe request.</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*YrH822kmlzI1rKdC7ouaXQ.png" /><figcaption><em>How a predictable executable path and writable directory can cross a privilege boundary.</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*chNf7CtY4gRvlk0-WTAZSA.png" /><figcaption><em>Example process tree: a visible Calculator window is not enough; the child-process token must also be verified.</em></figcaption></figure><h3>The idea</h3><p>EXE hijacking occurs when an application launches another program using an unsafe path or assumes an executable will exist in a location that a less-trusted user can control. If a privileged process later launches the attacker-controlled file, the payload inherits the caller’s security context.</p><h3>Discover the candidate</h3><p>Run Process Monitor as Administrator and add these filters:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1bTCRsTpM3o9IR1ahInxHA.png" /></figure><p>Exercise VWA for at least a minute. In the published VWA lab behavior, Beeper.exe attempts to load PipeClient.exe from:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zZxOLQiciSJ4B7_VDEawGg.png" /></figure><p>Confirm this in your own trace. Then examine the directory ACL:</p><p>Look for a write, modify or full-control permission granted to Users, Authenticated Users or another broad group. Also use Process Explorer to record the user and integrity level under which Beeper.exe runs.</p><h3>Safe validation</h3><p>Sign in as the standard user. If your ACL evidence shows that the account can write the file, copy Calculator as the expected executable name:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EUcXCcfVFHE4foOlpOCDkg.png" /></figure><p>Return to the administrator session and monitor the relevant process. If Calculator starts as a child of Beeper.exe, capture the process tree and its security context. That demonstrates control of program execution without creating a destructive payload.</p><p>Remove the copied file after collecting evidence:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7VI0HpBfp8-zp6EyoopGlg.png" /></figure><h3>Why it matters</h3><p>The problem is not simply a missing executable. The exploitable chain is:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*iS5oknLDJJC7KUB4egRJng.png" /></figure><p>Recommended fixes include using a fully qualified trusted path, shipping the required executable in a protected directory, restricting ACLs, validating the child binary and running the caller with the least privilege required.</p><h3>8. Exercise 2: DLL hijacking</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*VvEDDlVEZ-DO_MpXpWq6LQ.png" /><figcaption><em>Safe DLL-hijacking validation with a harmless message box and a recorded Load Image event.</em></figcaption></figure><h3>The idea</h3><p>Windows applications load libraries by name or by full path. If a program asks for Shared.dll without securely resolving its location, Windows may search several directories. A writable directory in that search sequence can allow an attacker-controlled DLL to be loaded.</p><h3>Discover the load attempt</h3><p>In Procmon, use:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uF7UzQAoyh44jL7loJLIlg.png" /></figure><p>Start or reinstall the relevant VWA component and observe the paths in order. VWA is designed so that Beeper.exe looks for a missing Shared.dll under C:\ProgramData\Viparva. Confirm all three conditions:</p><p>34. The DLL name is requested.</p><p>35. The directory is writable by a standard user.</p><p>36. The consuming process runs at a higher privilege or crosses another trust boundary.</p><h3>Build a harmless message-box DLL</h3><p>Create Shared.cpp inside your lab:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*wndioOwZbxqS1zpvpj8yKg.png" /></figure><p>Compile for the architecture of the target process. With 64-bit MinGW-w64:</p><p>With a Visual Studio Developer Command Prompt, an equivalent lab build is:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qB12vMsoUEyheJDqzi2GSQ.png" /></figure><p>Do not assume that the operating system and target process have the same architecture. Process Explorer can show whether the process is 32-bit or 64-bit.</p><h3>Validate and prove the load</h3><p>As the standard user, place the harmless DLL into the writable candidate directory:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y5f9EQaQVcsnJCZa8D66Ag.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VgLFSYk-tDBGz2_P2lkbgA.png" /></figure><p>Wait for the component to perform its periodic action or restart it using the normal VWA workflow. A message box is visible evidence, but Procmon and Process Explorer provide stronger proof. Capture a Load Image event for the DLL and show that Beeper.exe loaded it from the writable path.</p><p>Then delete the PoC and restore the snapshot. Loading code from DllMain is acceptable for this tiny training signal, but production code should avoid complex work there because of loader-lock constraints.</p><h3>Remediation</h3><p>Developers should reference trusted libraries with fully qualified paths where possible, keep application directories non-writable to unprivileged users, use secure DLL-loading APIs and flags, remove unsafe current-directory searches, and package all required dependencies. Re-test by confirming that the process no longer probes an attacker-writable path.</p><h3>9. Exercise 3: insecure local permissions</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*E_83ls-aifWp6c84Z2EszA.png" /><figcaption><em>The key question is whether a standard user controls input later trusted by a privileged process.</em></figcaption></figure><p>The first two exercises depend on an underlying weakness: a broad group can modify application data that influences a more-privileged component. Treat that as its own review area rather than only as part of a hijack.</p><p>Export ACLs for every application directory:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1ZW21zKYmsbSSFAZ9zmROg.png" /></figure><p>Ask:</p><p>· Can a standard user replace an executable, DLL or configuration file?</p><p>· Can they create a file that a privileged process will later open?</p><p>· Are permissions inherited unexpectedly from ProgramData?</p><p>· Can they delete or rename a protected application object?</p><p>· Does an updater trust a user-writable download or staging directory?</p><p>For a non-destructive check, create and delete a simple text file as the standard user in each candidate directory. Do not overwrite real binaries. Record the exact access-control entry that grants the permission.</p><p>The fix is to grant users only the access the application requires. Program binaries should generally reside under a protected installation directory. If users need to write application data, separate it from executable content and ensure privileged processes treat that data as untrusted.</p><h3>10. Exercise 4: information leakage in a binary</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*b9aZsMxstEglTug63JZNjg.png" /><figcaption><em>Example string-reference review using a synthetic, redacted lab credential.</em></figcaption></figure><h3>Static triage first</h3><p>Before debugging, collect metadata and signatures:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RL8SDZzVpmK8iGw0tjVe1w.png" /></figure><p>You can also use Sysinternals Sigcheck:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dOW5e8V1btmyy5zV6KjLbA.png" /></figure><p>Next, open Client.exe in x64dbg. Navigate to the module, search the current module for string references and review readable strings. VWA intentionally demonstrates that sensitive data can be embedded in a client binary. Record the offset and cross-reference the code that uses the value, but redact the full secret from public screenshots unless disclosure is part of the lab lesson.</p><h3>Why “obfuscate the string” is not the full fix</h3><p>If the application needs a reusable secret to authenticate itself, hiding it with Base64, XOR or ordinary obfuscation only increases the time needed to recover it. At some point the client must reconstruct the secret, making it observable in code or memory.</p><p>Prefer short-lived, user- or device-bound credentials; operating-system-backed secret storage; server-issued tokens with narrow scopes; rotation; and server-side authorization. Do not embed a universal production credential in every installed copy.</p><h3>Runtime memory review</h3><p>With authorization, attach a debugger to the VWA process and search memory after the relevant operation. Test before login, during authentication and after logout. A valuable question is not merely whether a password appears momentarily — it often must — but whether unnecessary copies remain for a long time, appear in logs or can be read by unrelated low-privileged processes.</p><p>Avoid collecting real user secrets. Use synthetic lab credentials and securely delete memory dumps when the assessment is complete.</p><h3>11. Exercise 5: insecure client-server communication</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*FL-pXik2-fbYL5su8kb8iQ.png" /><figcaption><em>Example clear-text lab traffic using documentation-only IP addresses and synthetic credentials.</em></figcaption></figure><p>VWA includes Client.exe and Server.exe to demonstrate communication risks. Launch the server using the lab’s normal workflow, start packet capture, and then launch the client.</p><p>First identify the endpoint:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1mAys1N4RBUoIonx3w5LfQ.png" /></figure><p>Use TCPView or Process Explorer to map a connection to the owning VWA process. In Wireshark, filter by the discovered TCP port:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C8H9ZD7HJChTkcvzXu2gnw.png" /></figure><p>Follow the TCP stream. Ask:</p><p>· Is sensitive data readable as plain text?</p><p>· Is TLS used?</p><p>· If TLS is present, does the client reject an untrusted certificate?</p><p>· Can a captured message be replayed?</p><p>· Does the server authenticate and authorize every sensitive action?</p><p>· Is message integrity protected, or can values be changed in transit?</p><p>The original VWA training scenario uses Echo Mirage to inspect the conversation between the client and server. Older interception tools can be unstable on newer Windows builds, so do not spend hours forcing one tool to work. A Wireshark capture inside the isolated VM may already give enough evidence to demonstrate clear-text exposure. Never weaken production TLS or install an interception certificate outside your authorized lab.</p><p>A proper fix normally uses TLS with correct certificate and hostname validation, a modern protocol configuration and a secure authentication design. Encryption alone does not fix missing authorization or replay weaknesses.</p><h3>12. Exercise 6: symlink attack analysis</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*ngvIqV9VbU041J29SF9qfw.png" /><figcaption><em>A non-destructive symlink exercise that redirects only to a harmless lab file.</em></figcaption></figure><h3>The idea</h3><p>A symbolic link or another reparse point redirects a file operation to a different target. A privileged installer or service can be vulnerable if it writes through a path that a standard user can prepare or replace.</p><p>VWA’s training scenario focuses on its log location:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*J4gy6E9WlfS9qz0Xm8Mm8g.png" /></figure><p>The security question is: can a low-privileged user control the path while a privileged process later writes to it?</p><h3>Safe validation approach</h3><p>Do not redirect the lab write into C:\Windows or overwrite an operating-system file. Use a harmless target in a dedicated folder, for example:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*qJBuUcNgogL-uszr1kuJcg.png" /></figure><p>Take a snapshot, use the official symbolic-link testing tool referenced by the VWA project, and reproduce the path redirection only inside the disposable VM. Capture:</p><p>· the ACL on the original directory;</p><p>· the reparse point and its target;</p><p>· the privileged writer’s Procmon event;</p><p>· the harmless text written at the alternate location.</p><p>Then roll back the snapshot. This demonstrates the primitive without risking system availability.</p><p>Developers should create privileged directories with restrictive ACLs, safely open files without following attacker-controlled reparse points where appropriate, validate the final resolved path and avoid predictable writable staging locations. Installers should assume pre-existing paths may be hostile.</p><h3>13. What I would test next</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*kKFhtaRv2DzwuV-ITkckDg.png" /><figcaption><em>Eight additional VWA modules to explore safely and document carefully.</em></figcaption></figure><p>VWA includes more vulnerable modules than I can properly demonstrate in one beginner article. Instead of turning them into a wall of payloads, these are the questions I would use for the next round of testing.</p><h3>Unquoted service path</h3><p>Enumerate VWA-related services and inspect PathName. A path containing spaces is suspicious when it is unquoted, but not automatically exploitable. Determine whether Windows could interpret an earlier path segment as an executable and whether a standard user can create that file. Report the full chain, the service account and restart permissions. Fix the issue by quoting the executable path and protecting every directory in it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nn9zxmvCA40bYwwDvmblcw.png" /><figcaption>Unquoted service path</figcaption></figure><h3>IFEO injection</h3><p>Image File Execution Options can associate a debugger with a named executable. Review relevant keys under:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*wLLADKPFUM5VbZWZXfsDaw.png" /></figure><p>Determine who can modify the applicable key and what privileged process later launches the target. Do not set persistence on a real system. In the VM, use Regshot and a harmless executable to understand the behavior, then revert. Defenders should restrict registry ACLs and monitor unexpected Debugger values.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9zL9jH1yIKHA52T-04968A.png" /><figcaption>IFEO injection detection</figcaption></figure><h3>Weak named pipe</h3><p>Use Process Explorer, WinObj or an appropriate pipe-enumeration utility to identify VWA named pipes. Examine the pipe’s security descriptor and determine whether an unrelated standard user can connect, read, write or impersonate. Send only benign test data. The server should use a restrictive ACL, authenticate the peer, validate every message and avoid trusting the pipe name as proof of identity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MJGEk0Uwcph4COZ566zevA.png" /><figcaption>Weak named pipe</figcaption></figure><h3>Weak memory protection</h3><p>Record process mitigation settings and check whether another process at the same or lower trust level can obtain excessive access to VWA. Look for long-lived secrets and unnecessary process handles. A finding should state which identity can read which data and under what conditions — not merely that a debugger can inspect a process owned by the same user.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vUdQMMS5-5Xqgu7lR2iA0A.png" /><figcaption>Weak memory protection</figcaption></figure><h3>Stack buffer overflow</h3><p>Use a debugger in the isolated VM, provide a gradually increasing benign pattern and record whether the application crashes. Stop after confirming controllable corruption; do not develop a weaponized exploit. Document input length, exception type, affected module and modern mitigations such as DEP, ASLR, stack cookies and Control Flow Guard. The root fix is bounds-safe input handling, not reliance on mitigations alone.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gGdBXLwXLPBUilvWjkTQSA.png" /><figcaption>Stack buffer overflow</figcaption></figure><h3>Absence of digital signatures</h3><p>Run PowerShell’s Get-AuthenticodeSignature or Sigcheck across all installed .exe, .dll and .msi files. An unsigned binary is not automatically exploitable, but it weakens publisher verification and update trust. Combine the result with evidence of an insecure delivery or update mechanism when rating impact.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4bW44OXZEqAFbO4FJpAM_A.png" /><figcaption>Absence of digital signatures</figcaption></figure><h3>COM hijacking</h3><p>Capture registry activity and look for COM class identifiers requested by the application. Determine whether registration is resolved from a user-writable location and whether the consuming process crosses an integrity boundary. Use only a message-box in the VM for validation. Developers should avoid unsafe per-user fallback for privileged components and protect registration paths.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2EGYrNYhAs-8Ixc_H01ckQ.png" /><figcaption>COM hijacking</figcaption></figure><h3>Process injection</h3><p>Treat this module as an observation exercise. Map process access rights, integrity levels and mitigations. Validate with the lab’s benign functionality or debugger rather than shellcode. A meaningful finding explains why an untrusted process can obtain dangerous rights to a more-trusted target and what security boundary is crossed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cbhyti4iBofVCSSRFthTGg.png" /><figcaption>Process injection detection</figcaption></figure><h3>14. Turning evidence into a professional finding</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*Qsdv1c6sXUaVlvw4IRE1ew.png" /><figcaption><em>Tool output becomes useful when the report explains the affected trust boundary.</em></figcaption></figure><p>A good report makes the issue reproducible without forcing the reader to interpret a giant Procmon trace.</p><p>Use this structure:</p><p><strong>Title:</strong> Privileged Beeper.exe loads Shared.dll from a directory writable by standard users</p><p><strong>Severity:</strong> High (adjust using the actual execution context and environmental prerequisites)</p><p><strong>Affected component:</strong> Exact version, file path and SHA-256 hash</p><p><strong>Description:</strong> Explain the insecure search behavior and permissions in two or three sentences.</p><p><strong>Prerequisites:</strong> State whether local access, a standard account, service restart or user interaction is required.</p><p><strong>Steps to reproduce:</strong> Include only the minimum deterministic sequence.</p><p><strong>Evidence:</strong> Provide the Procmon load event, directory ACL, process tree, user/integrity level and screenshot of the harmless message box.</p><p><strong>Impact:</strong> Explain the trust boundary crossed. Avoid vague claims such as “an attacker can hack the system.”</p><p><strong>Remediation:</strong> Recommend an engineering change and a permissions change, where relevant.</p><p><strong>Retest:</strong> Show that the fixed application no longer searches or loads from the writable directory.</p><p>Separate symptoms from root causes. EXE hijacking and DLL hijacking may both originate from the same insecure directory permissions and unsafe path resolution. Your report should help developers fix the class of issue, not play whack-a-mole with filenames.</p><h3>15. Remediation checklist for thick-client developers</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*3h0EaQkYQesdD-oEmduDTQ.png" /><figcaption><em>A defensive checklist for Windows thick-client developers.</em></figcaption></figure><p>· Run each process and service with the least privilege required.</p><p>· Store executables and libraries only in directories ordinary users cannot modify.</p><p>· Use absolute, trusted paths when launching child processes.</p><p>· Quote service executable paths and protect every parent directory.</p><p>· Use secure DLL-loading behavior and package dependencies explicitly.</p><p>· Treat local configuration, environment variables and IPC messages as untrusted input.</p><p>· Apply restrictive ACLs to files, directories, registry keys, services and named pipes.</p><p>· Use TLS with correct certificate and hostname validation.</p><p>· Enforce authentication and authorization on the server for every sensitive action.</p><p>· Do not embed reusable universal secrets in client binaries.</p><p>· Use short-lived scoped tokens and OS-backed credential storage.</p><p>· Sign installers, executables, libraries and update packages.</p><p>· Verify update integrity and publisher identity before installation.</p><p>· Compile with current memory-safety mitigations and use bounds-safe APIs.</p><p>· Remove sensitive data from memory when it is no longer needed.</p><p>· Log security events without logging credentials, tokens or personal data.</p><p>· Test installation, repair, update and uninstall flows — not only the main UI.</p><h3>16. What I learned from this lab</h3><p>When testing is complete:</p><p>37. Stop VWA processes and packet captures.</p><p>38. Export only the evidence required for your report.</p><p>39. Remove synthetic secrets and memory dumps from shared locations.</p><p>40. Revert the VM to the clean snapshot or delete it.</p><p>The biggest lesson for me is that thick-client testing is really a study of trust. Process Monitor shows what a program searches for. Permissions show who can control the result. Process Explorer shows which identity consumes it. A debugger reveals how the program handles local data, while a packet capture reveals what crosses the network.</p><p>None of those facts is automatically a vulnerability. The finding appears when they join into an unsafe chain. In the EXE-hijacking exercise, for example, the missing executable was only the first clue. The writable directory and the more-privileged caller were what made it important.</p><p>VWA is a useful beginner target because one small lab covers files, processes, services, memory and communication. I recommend completing one module at a time and writing a short finding immediately afterward. When the test is repeated from a clean snapshot, weak assumptions become obvious very quickly.</p><p>Treat this article as a starting checklist, not the final word. During an authorized assessment, record the Windows version, tool versions, failed attempts and timing observations. Those small details are often the most useful part when reproducing a finding.</p><p>Happy hacking. Keep the VM isolated, use harmless proofs of concept and test only systems you are authorized to assess.</p><blockquote>For personalize training Contact : pentestersandy@gmail.com</blockquote><h3>References</h3><p>· <a href="https://github.com/DarkRelay-Security-Labs/VWA">DarkRelay Security Labs — VWA GitHub repository</a></p><p>· <a href="https://www.darkrelay.com/post/thick-client-penetration-testing">DarkRelay — Thick Client Penetration Testing</a></p><p>· <a href="https://learn.microsoft.com/sysinternals/downloads/procmon">Microsoft Sysinternals — Process Monitor</a></p><p>· <a href="https://learn.microsoft.com/windows/win32/dlls/dynamic-link-library-security">Microsoft — Dynamic-link library security</a></p><p>· <a href="https://learn.microsoft.com/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessw">Microsoft — CreateProcess executable-name behavior</a></p><p>· <a href="https://learn.microsoft.com/windows/win32/services/service-security-and-access-rights">Microsoft — Service application security and access rights</a></p><p>· <a href="https://learn.microsoft.com/windows-hardware/drivers/install/authenticode">Microsoft — Authenticode</a></p><p>· <a href="https://github.com/googleprojectzero/symboliclink-testing-tools">Google Project Zero — Symbolic Link Testing Tools</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f5ad6233bf35" width="1" height="1" alt=""><hr><p><a href="https://osintteam.blog/windows-thick-client-penetration-testing-f5ad6233bf35">Step-by-Step Beginner’s Guide to Windows Thick-Client Penetration Testing with VWA</a> was originally published in <a href="https://osintteam.blog/">OSINT Team</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Zigbee Protocol Security (IoT Security)]]></title>
            <link>https://osintteam.blog/zigbee-protocol-security-iot-security-2ab4aee52736?source=rss-1125fd6b489d------2</link>
            <guid isPermaLink="false">https://medium.com/p/2ab4aee52736</guid>
            <category><![CDATA[iot-security-market]]></category>
            <category><![CDATA[iot-security]]></category>
            <category><![CDATA[iot-security-industry]]></category>
            <category><![CDATA[iot]]></category>
            <dc:creator><![CDATA[Sandeep Vishwakarma]]></dc:creator>
            <pubDate>Sat, 06 Sep 2025 10:46:43 GMT</pubDate>
            <atom:updated>2025-09-07T19:02:22.418Z</atom:updated>
            <content:encoded><![CDATA[<p>Greetings fellow hackers, my name is Sandy, InfoSec Consultant and Bug bounty hunter. As I’m presently engaged in IoT security and Zigbee protocol penetration testing, I’d like to relay my experiences with you, as they may prove beneficial in addressing some of the inquiries, I had difficulty resolving answers too, without more introductions let’s get started.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2Ml9crU3GdNWnQDqgUOg3g.png" /></figure><p>In the vast landscape of the Internet of Things (IoT), communication protocols play a crucial role in enabling seamless connectivity. Zigbee, a wireless communication standard developed by the Zigbee Alliance, operates on the IEEE 802.15.4 radio frequency, specializing in low-power, short-range data transmission. Designed for applications in home automation, industrial control, and sensor networks, Zigbee stands out for its energy efficiency, scalability, and ability to form resilient mesh networks. Devices utilizing Zigbee can seamlessly communicate, forming interconnected networks that automatically adapt and self-heal. With its focus on minimizing power consumption and supporting a wide range of devices, Zigbee has gained prominence in the Internet of Things (IoT) ecosystem. Its flexibility makes it an ideal choice for smart home devices, facilitating reliable communication and contributing to the growth of interconnected and intelligent systems across various industries.</p><p><strong>Zigbee offers two distinct security modes:</strong></p><p><strong>Distributed Security Mode:</strong> In the Distributed Security Mode with a unique Trust Center, there is no mandatory requirement for the network, and routers take on the responsibility of authenticating end devices. Devices come pre-configured with a link key, while the network key is assigned by a router upon joining the network. It’s important to note that the network key remains constant for all nodes in the network, resulting in a relatively lower level of security compared to other modes.</p><p><strong>Centralized Security Mode:</strong> Contrastingly, the Centralized Security Mode is employed in applications where a trust center plays a pivotal role in controlling and maintaining the centralized security policy for both the network and devices. Under this mode, the trust center assumes the following responsibilities: 1. Maintenance of security and security configurations for the entire network.</p><ol><li>Authentication of devices and upkeep of a comprehensive list of devices connected to the network.</li><li>Management of both Link keys and Network keys, ensuring their distribution and association with all devices in the network.</li></ol><p><strong>Zigbee defines three types of devices:</strong></p><ul><li><strong>ZigBee Coordinator (ZC):</strong> This device starts the network and selects the channel and PAN ID. It also communicates with routers and connects devices.</li><li><strong>ZigBee Router (ZR):</strong> This device passes data between devices.</li><li><strong>ZigBee End Device (ZED):</strong> This device is the one that will be controlled.</li></ul><p><strong>Types of ZigBee Security Key</strong> <strong>Network Key</strong> The first key on our list is the Network key, a vital component for a ZigBee network. This key is used to encrypt and decrypt data as it flies across your network, keeping your data safe and protected. Each device on your network is given a copy of this key, allowing them to verify the data packets they receive.</p><ul><li>The Network key is updated periodically for long-term security.</li><li>Stored securely in every device in the network.</li></ul><p><strong>Master Key</strong> Next comes the Master key, a shared secret between devices in a ZigBee network. It’s used during the joining process when a new device is added to the network. The Master key helps establish an encrypted and authenticated channel between the new device and the Trust Center.</p><ul><li>It helps in safely adding new devices to the network.</li><li>Plays a crucial role in initial link security.</li></ul><p><strong>Trust Center Link Key</strong> Not to be forgotten is the Trust Center Link Key. This key is created during the process of joining a device to a network. It establishes a secure link between a device and the Trust Center, and plays a significant role in securing device management.</p><ul><li>Facilitates secure communication between devices and the Trust Center.</li><li>Essential for secure device management.</li></ul><p><strong>Application Key</strong> Finally, we have the Application Key, which encodes application data. This key is unique to each device and allows for personalized encryption and authentication, making it even more difficult for interlopers to access.</p><ul><li>Personalized encryption provides an additional security layer.</li><li>Ensures every device communicates securely.</li></ul><p><strong>Explanation of ZigBee encryption methods</strong> ZigBee utilizes the Advanced Encryption Standard (AES) 128-bit symmetric encryption. Encryption in ZigBee follows two steps:</p><ol><li>Symmetric key encryption for the actual message content</li><li>An added layer, known as an integrity code, which is encrypted along with the content</li></ol><p>In simple words, ZigBee AES encryption takes plaintext data, combines it with a secret key, and then transforms it into an unreadable text (ciphertext) — ensuring that the transmitted information could be accessed only by intended recipients.</p><p><strong>ZigBee Network architecture</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1ZwDUtGAX4Ik-R-h.png" /><figcaption><strong>Fig: ZigBee Network architecture</strong></figcaption></figure><p>ZigBee networks function based on a mesh network architecture where each device, or ‘node’, can connect to multiple others within its range, creating multiple potential paths for data transmission. Unlike traditional hierarchical networks, this structure enables ZigBee networks to be incredibly resilient and flexible. If one device or pathway fails, data can be rerouted through another, ensuring consistent and reliable communication. This innovatively dynamic architecture makes ZigBee networks ideal for smart home systems.</p><ul><li>Mesh Network Structure: Interconnected device nodes, forming multiple data paths.</li><li>Resiliency: Data can be rerouted if a pathway fails.</li><li>Flexibility: Capable of adapting to changes and device additions.</li></ul><p><strong>Key Features:</strong></p><ul><li><strong>Low Power Consumption:</strong> Zigbee devices are designed for energy efficiency, making them suitable for battery-powered applications with extended operational life.</li><li><strong>Mesh Networking:</strong> Zigbee supports mesh networking, enabling devices to communicate through multiple paths, enhancing reliability and coverage in interconnected networks.</li><li><strong>Security Features</strong>: Zigbee incorporates robust security measures, including encryption and authentication, ensuring secure communication and protection against unauthorized access.</li><li><strong>Interoperability</strong>: Zigbee devices adhere to standardized profiles, fostering interoperability among products from different manufacturers and enabling diverse ecosystems.</li><li><strong>Scalability:</strong> Zigbee networks can scale from small to large setups, accommodating varying numbers of devices and addressing the needs of different applications.</li></ul><p><strong>Applications of Zigbee</strong></p><ol><li><strong>Smart Home Automation:</strong> Zigbee has found its niche in smart home applications. From smart lighting and thermostats to security systems and smart locks, Zigbee provides a robust and reliable communication framework for interconnected smart home devices.</li><li><strong>Industrial IoT (IIoT):</strong> In the industrial landscape, Zigbee is making significant strides. Its ability to handle a large number of devices in a network, coupled with low power consumption, makes it suitable for industrial automation, asset tracking, and monitoring.</li><li><strong>Healthcare and Wearables:</strong> Zigbee’s low-power capabilities make it a viable option for healthcare applications, particularly in wearables and medical devices. It allows for continuous monitoring without draining the device’s battery quickly.</li></ol><p><strong>Security Approach</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1019/0*7uz7o85XCKI_-DNl.png" /></figure><p><strong>Vulnerabilities in ZigBee</strong></p><p><strong>Insecure Storage of Security Keys:</strong> The ZigBee protocol assumes that all security keys, including network and Link keys, are stored securely on devices. However, if not handled properly, these keys can be vulnerable to identification through reverse-engineering of the firmware binary. Securing the storage of keys is crucial to prevent unauthorized access through such reverse-engineering techniques.</p><p><strong>Over-The-Air Insecure Key Transmission:</strong> Certain implementations pose a security risk during the initial integration of a node into a ZigBee network. In such instances, the node acquires its keys over-the-air, often in clear-text format from the coordinator. This approach exposes a potential vulnerability, as a network sniffer or rogue device can intercept these keys from the coordinator, posing a threat to the overall network security.</p><p><strong>Energy Depletion Attacks:</strong> Two prevalent energy depletion attacks are noteworthy:</p><ol><li>Invalid Security Header: Attackers send bursts of packets with invalid security headers, intending to force the targeted device to expend energy verifying frame integrity. This deliberate act accelerates the battery depletion of the target device, leaving it susceptible to compromise.</li><li>Polling Rate: In this attack, adversaries inundate the end device with packets at a rate surpassing the network’s configured polling rate. This rapid influx of packets accelerates the energy consumption, leading to faster battery depletion of the target device. Vigilance against these energy depletion attacks is essential to maintain the resilience of ZigBee networks.</li></ol><p><strong>Network Jamming Vulnerability:</strong> While IEEE802.15.4/ZigBee standards incorporate protection mechanisms against radio and network interference, certain vulnerabilities exist, allowing attackers to employ jamming techniques. — <strong>Radio Jamming:</strong> In radio jamming attacks, the assailant amplifies the emission of the radio signal on a specific channel, causing a reduction in the Signal to Noise Ratio of the radio channel. This deliberate interference disrupts the normal functioning of the ZigBee network, potentially leading to connectivity issues and compromised communication.</p><ul><li><strong>Link Layer Jamming:</strong> Link Layer jamming attacks target the MAC layer, where the attacker transmits bursts of random ZigBee frames containing useless data onto the network. These transmissions occur either at random intervals or specific intervals, strategically aimed at particular nodes. This disruptive action results in packet drops and initiates a Denial of Service (DoS) attack within the ZigBee network, impacting its overall performance and reliability. Countermeasures against such jamming attacks are crucial for ensuring the robustness of ZigBee networks.</li></ul><p><strong>Unauthenticated ACK Frame Vulnerability:</strong> While the Acknowledgment (ACK) frame is a crucial component of the network layer in IEEE 802.15.4/ZigBee standards, it is limited to confirming frame transmission without providing integrity and confidentiality protections for acknowledgment packets. This limitation opens the door to potential vulnerabilities.</p><ul><li><strong>ACK Spoofing:</strong> In ACK Spoofing attacks, assailants jam the network to prevent legitimate devices from receiving frames. Subsequently, the attacker sends a deceptive ACK frame with the correct sequence number to the sender. This deceptive action results in data loss within the ZigBee network, impacting its overall reliability and security.</li><li><strong>ACK Dropping:</strong> ACK Dropping attacks involve the attacker jamming the network in a way that only the ACK frame from the receiver to the sender is affected. By disrupting this critical acknowledgment, the attacker forces the sender to repeatedly retransmit data until the maximum number of retransmissions is reached. This not only depletes the network bandwidth but also drains the battery power of the devices, leading to potential service disruptions and reduced operational efficiency. Vigilance against these ACK-related vulnerabilities is essential for maintaining the robustness of ZigBee networks.</li></ul><p><strong>Replay-Protection Vulnerability:</strong> While IEEE 802.15.4 incorporates replay-protection mechanisms, there exists a vulnerability that can be exploited by attackers,The standard’s replay-protection feature dictates that a node can discard a received frame if its sequence number is equal to or less than the sequence number of the previously received frame from the same source node. In replay-protection attacks, a malicious actor can exploit this mechanism by sending frames with artificially inflated sequence numbers to the target node. Consequently, the target node, adhering to the replay-protection rule, drops frames with smaller, legitimate sequence numbers. This intentional manipulation compromises the integrity of data transmission, potentially leading to data loss, service disruptions, and security breaches within the IEEE 802.15.4 network. Ensuring robust countermeasures against such replay-protection vulnerabilities is essential for maintaining the overall security and reliability of the network.</p><p><strong>Tools &amp; Installation:</strong></p><ul><li><strong>KillerBee:</strong> It is a Framework and Tools for Testing &amp; Auditing ZigBee and IEEE 802.15.4 Networks.</li><li><strong>Z3sec:</strong> It is an open-source penetration testing framework comprising a set of command line tools for ZigBee security research. Primary targets of the framework are ZigBee-certified devices that implement either the ZigBee Light Link (ZLL) or the ZigBee 3.0 standard.</li></ul><p><strong>Best Practices for Managing ZigBee Security Keys</strong></p><p>The management of Zigbee security keys is the most priority to ensure the protection of your smart home devices. Here are a few best practices:</p><p>• Do not share your network key with anyone you do not trust.</p><p>• Regularly update the security key, ideally every three months.</p><p>• Always use two-factor authentication whenever it’s provided.</p><p>• Always keep a backup of your key in a secure location.</p><p><strong>In conclusion,</strong> Zigbee is more than just a wireless protocol; it’s a driving force behind the seamless connectivity of IoT devices. As we move towards a more interconnected future, Zigbee stands tall, connecting the dots and powering the next wave of innovation in the Internet of Things.</p><blockquote>for more Contact : sv110040@gmail.com</blockquote><p><strong>References:</strong></p><p><a href="https://en.wikipedia.org/wiki/Zigbee%3E">https://en.wikipedia.org/wiki/Zigbee%3E</a></p><p><a href="https://en.wikipedia.org/wiki/IEEE_802.15.4">https://en.wikipedia.org/wiki/IEEE_802.15.4</a></p><p><a href="https://standards.ieee.org/standard/802_15_4-2020.html%3E">https://standards.ieee.org/standard/802_15_4-2020.html%3E</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ab4aee52736" width="1" height="1" alt=""><hr><p><a href="https://osintteam.blog/zigbee-protocol-security-iot-security-2ab4aee52736">Zigbee Protocol Security (IoT Security)</a> was originally published in <a href="https://osintteam.blog/">OSINT Team</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Step-by-step Complete Setup Guide for Automotive Application Testing (AAOS Emulator)]]></title>
            <link>https://infosecwriteups.com/step-by-step-complete-setup-guide-for-automotive-application-testing-aaos-emulator-29ffcab3fda9?source=rss-1125fd6b489d------2</link>
            <guid isPermaLink="false">https://medium.com/p/29ffcab3fda9</guid>
            <category><![CDATA[pentesting]]></category>
            <category><![CDATA[automotive]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[android-studio]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <dc:creator><![CDATA[Sandeep Vishwakarma]]></dc:creator>
            <pubDate>Fri, 15 Aug 2025 19:12:33 GMT</pubDate>
            <atom:updated>2025-09-05T05:41:01.564Z</atom:updated>
            <content:encoded><![CDATA[<p>Greetings fellow hackers, my name is Sandy, InfoSec Consultant and Bug bounty hunter.</p><p>As I’m presently engaged in Automotive Application penetration testing, I’d like to relay my experiences with you, as they may prove beneficial in addressing some of the inquiries, I had difficulty resolving answers too, without more introductions let’s get started.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fdd4WOGqPUf3CjOLBlBSTQ.png" /></figure><p>This blog will encompass all of these elements.</p><h3>Table of Contents</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*5gPk3seEnv_4gSZXkqV0QQ.png" /><figcaption>Table of Contents</figcaption></figure><h4>The rise of Android Automotive OS</h4><p>The modern automobile is undergoing a rapid transformation, shifting from a mechanical machine to a sophisticated, connected computing platform. The key to this change is <strong>Android Automotive OS (AAOS)</strong>, a full operating system that makes the car itself an Android device. This is a fundamental difference from <strong>Android Auto</strong>, which simply displays content from your phone. This integration allows for a deep connection between the infotainment experience and the vehicle’s core functions, enabling features like on-screen climate control, detailed navigation, and a rich ecosystem of third-party applications. This profound integration marks a new era in vehicle technology.</p><h4>Why security testing is critical</h4><p>With this increased connectivity and deep system integration comes a new frontier for security. A vulnerability in an automotive application or the AAOS framework itself could have far more serious consequences than a bug in a smartphone app. A compromise could lead to a variety of risks, from exposing sensitive user data to potentially affecting critical vehicle functions. The security of AAOS and the applications that run on it is therefore not just about data privacy — it’s about <strong>vehicle safety and integrity</strong>. Comprehensive security testing is a non-negotiable step to ensure these systems are protected against malicious attacks.</p><h4>What this guide will cover</h4><p>This guide provides a comprehensive, step-by-step walkthrough to get you started in automotive application security testing. We’ll begin by building your foundational test lab, from creating and configuring the AAOS emulator to using command-line tools for low-level interaction. From there, we’ll dive into the core of security analysis: installing and preparing a test application and configuring the environment to intercept and analyze all network traffic, including encrypted HTTPS requests. By the end, you’ll have the practical skills and a working environment to begin your journey into this critical field.</p><h3>Prerequisites</h3><p>Before we start, make sure you have:</p><ul><li><strong>RAM:</strong> Minimum 8 GB (16 GB recommended for smooth emulation)</li><li><strong>Storage:</strong> 10+ GB free space</li><li><strong>CPU:</strong> Intel VT-x/AMD-V enabled in BIOS</li><li><strong>Software:</strong></li></ul><blockquote><em>Android Studio (latest version)</em></blockquote><blockquote><em>Android SDK + Command-line tool</em></blockquote><blockquote><em>Java JDK 11 or above</em></blockquote><blockquote><em>ADB (Android Debug Bridge)</em></blockquote><h3>Environment Setup</h3><h3>1) Open Android Studio</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ksr4ONbJpzzQI8E0" /></figure><h3>2) Open Virtual Device Manager</h3><p>Click <strong>More Actions → Virtual Device Manager</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YmCE1_2lrpiLRSRI" /></figure><h3>3) Create a new virtual device</h3><p>In <strong>Device Manager</strong>, click <strong>Create virtual device…</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*01j-4P96jTZ4Ftai" /></figure><h3>4) Choose the Automotive device profile</h3><p>In <strong>Add Device → Form Factor</strong>, select <strong>Automotive</strong>.<br> Pick <strong>Automotive Distant Display with Google Play</strong> (1080×600, 120 dpi).<br> Click <strong>Next</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TAypXy7sNSwfqF0i" /></figure><h3>5) Select the exact system image</h3><p>In <strong>Configure virtual device</strong>:</p><ul><li>Name: <em>Automotive Distant Display with Google Play</em> (or your preferred name)</li><li>API: <strong>API 33 “Tiramisu”</strong></li><li>Services: <strong>Google Play Store</strong></li><li>System Image: <strong>Automotive Distant Display with Google Play x86_64 System Image (API 33)<br></strong> Click <strong>Finish</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8ZHx827zL5iUoQUD" /></figure><h3>6) Confirm download</h3><p>Android Studio will prompt to download the image, which is approximately 1.2 GB. Click <strong>Yes</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GcZIH2wJxpn0Sr3p" /></figure><h3>7) Observe the download</h3><p>The <strong>SDK Component Installer</strong> shows x86_64–33_playstore_r02.zip downloading.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EkZz_AYnwLtOQNdp" /></figure><h3>8) Installation complete</h3><p>When the installer shows <strong>Done</strong>, click <strong>Finish</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*epzo7vNa7xBrBkRO" /></figure><h3>9) Verify the AVD is created</h3><p>Back in <strong>Device Manager</strong>, you should see:<br> <strong>Automotive Distant Display with Google Play — API 33 — Virtual</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XXpMgYvTxMaOaECh" /></figure><h3>10) Launch the emulator</h3><p>Click the <strong>Run</strong> ▶ icon. The emulator boots (Google splash).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9p7Ifxq6SnqgTN3m" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*m8eiQg5AlKhm1BPq" /></figure><h4>11) Check the config.ini file</h4><p>Once the emulator has booted up, Android Studio automatically generates a configuration file for your AVD. You can find this file by navigating to <strong>C:\Users\Sandy\.android\avd\Automotive_Distant_Display_with_Google_Play.avd</strong> on your system. This directory contains the configuration files and the disk images for your emulator. Open the <strong>config.ini</strong> file to view the settings.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wVtPkUv_nMs8nNbD" /></figure><h4>12) Review the config.ini details</h4><p>Inside the config.ini file, you can see the hardware and system properties of your AVD. Pay close attention to the avd.ini.displayname which confirms the correct emulator profile is being used. You can also see important parameters like cpu.ncore and ramSize which define the virtual device’s resources.</p><blockquote>AvdId = [your_new_avdid]<br>PlayStore.enabled = false<br>abi.type = x86_64<br>avd.ini.displayname = [your_new_avdid]<br>avd.ini.encoding = UTF-8<br>disk.dataPartition.size = 6442450944<br>fastboot.chosenSnapshotFile = <br>fastboot.forceChosenSnapshotBoot = no<br>fastboot.forceColdBoot = yes<br>fastboot.forceFastBoot = no<br>hw.accelerometer = yes<br>hw.arc = false<br>hw.audioInput = yes<br>hw.battery = no<br>hw.camera.back = none<br>hw.camera.front = none<br>hw.cpu.arch = x86_64<br>hw.cpu.ncore = 4<br>hw.dPad = no<br>hw.device.hash2 = MD5:5f6209fe11b596feb0d470effb1a9a6b<br>hw.device.manufacturer = Google<br>hw.device.name = [your_new_avdid]<br># Remove unsupported secondary display (can crash automotive AVD)<br># hw.display6.density = 120<br># hw.display6.flag = 0<br># hw.display6.height = 600<br># hw.display6.width = 400<br>hw.gps = yes<br>hw.gpu.enabled = yes<br>hw.gpu.mode = swiftshader_indirect<br>hw.gyroscope = yes<br>hw.initialOrientation = landscape<br>hw.keyboard = yes<br>hw.lcd.density = 160<br>hw.lcd.height = 792<br>hw.lcd.width = 1408<br>hw.mainKeys = no<br>hw.ramSize = 4096<br>hw.sdCard = yes<br>hw.sensors.light = yes<br>hw.sensors.magnetic_field = yes<br>hw.sensors.orientation = yes<br>hw.sensors.pressure = no<br>hw.sensors.proximity = no<br>hw.trackBall = no<br>image.sysdir.1 = system-images\android-33\android-automotive\x86_64\<br>runtime.network.latency = none<br>runtime.network.speed = full<br>sdcard.size = 512M<br>showDeviceFrame = no<br>skin.dynamic = yes<br>tag.display = Automotive<br>tag.displaynames = Automotive,Google APIs<br>tag.id = android-automotive<br>tag.ids = android-automotive,google_apis<br>target = android-33<br>vm.heapSize = 256</blockquote><h4>13) Review additional configuration details</h4><p>Scrolling down in the config.ini file reveals more settings. Key entries include hw.gps, hw.gpu.mode, and hw.lcd.density which are configured for the automotive use case. The tag.display and tag.id fields confirm this is an Android Automotive AVD with Google APIs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/849/0*sxgpVlX9m2Km43j9" /></figure><h4>14) Find the emulator executable</h4><p>To run the emulator from the command line, you need to locate its executable. The emulator.exe file is typically found in C:\Users\&lt;username&gt;\AppData\Local\Android\Sdk\emulator. This location is important for running the emulator directly without Android Studio, which is often necessary for advanced testing or automation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gU0P5ySeAL630LzB" /></figure><h4>15) List your AVDs from the command line</h4><p>Open a command prompt or terminal and navigate to the emulator directory (from the previous step). Run the command emulator -list-avds. This will list all the Android Virtual Devices (AVDs) you have created, confirming that your “Automotive_Distant_Display_with_Google_Play” AVD is available to be launched.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/954/0*T8xnSaZ59YeziFDX" /></figure><h4>16) Launch the emulator from the command line</h4><p>To launch the emulator using the command line, use the command emulator -avd Automotive_Distant_Display_with_Google_Play. This command starts the AVD and displays a log of its boot process, including checks for hardware virtualization and system requirements.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gZmMRS7GAjNKiTtH" /></figure><h4>17) Observe the Google splash screen</h4><p>As the emulator starts, you will first see the <strong>Google splash screen</strong>, a clear sign that the AVD is booting up correctly. This screen confirms that you have successfully launched the virtual device.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jfdjhDMq0LZChrV4" /></figure><h4>18) Verify the home screen and app drawer</h4><p>After a few moments, the emulator will show the AAOS home screen, including the app launcher with various pre-installed apps like “News,” “Bluetooth Audio,” and “Contacts.” This confirms the AVD is fully operational and ready for you to install and test applications. You can use this state to begin your work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*FZLW2PuFmk1ZfupI" /></figure><h4>19) Get root access via adb</h4><p>To gain root access, which is crucial for security testing, open a new command prompt and type adb shell. Then, within the shell, use the command su. The prompt will change from $ to #, indicating that you have successfully gained <strong>root</strong> privileges. This is a powerful feature of the AAOS emulator, allowing for in-depth system analysis and manipulation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*r9FOAPqpdHkzdR4Y" /></figure><h4>20) Install an APK</h4><p>To test internet connectivity and HTTPS traffic, we’ll install a browser app. Use the <strong>adb install</strong> command from your Windows command prompt. In this case, the command is adb install “vai browser.apk”. Once the installation is successful, you will see a new browser icon on your AAOS emulator’s home screen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PaYgoFKVRUsiSYx2" /></figure><h4>21) Verify browser functionality</h4><p>Launch the newly installed browser. Try navigating to a website, for example, a blog or news site. This step confirms that the browser is working and that the emulator has a functional network connection, which is a prerequisite for proxying traffic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BXwk5Efa3aabM_6T" /></figure><h4>22) Export the CA certificate from Burp Suite</h4><p>On your host machine, open <strong>Burp Suite</strong> and navigate to the <strong>Proxy</strong> tab. Click on <strong>Proxy listeners</strong>, and then select <strong>Import/export CA certificate</strong> to begin the export process. This is the first step in getting the Burp Suite certificate onto the emulator so it can trust the proxy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vo0z62eOQ8l5UqWo" /></figure><h4>23) Select the export format</h4><p>In the CA Certificate window, choose <strong>Export</strong> and select the <strong>Certificate in DER format</strong> option. This is a binary format for the certificate. Click <strong>Next</strong> to proceed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*v1B0WBinIjSdSurQ" /></figure><h4>24) Save the certificate</h4><p>Choose a location to save the certificate file. The standard location is often the <strong>Documents</strong> or a designated project folder. Save the file with a .der extension (e.g., ca.der).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qDecSREyBuSTu3W_" /></figure><h4>25) Convert the certificate format</h4><p>Android requires the certificate to be in <strong>PEM</strong> format. On your Kali Linux or other Unix-like system, use the <strong>openssl</strong> command to convert the DER file to PEM. The command is openssl x509 -inform DER -in ca -out burp.pem. This command reads the binary DER input and writes it to a readable PEM file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/556/0*tgqN5Osssle1VI1S" /></figure><h4>26) Get the certificate subject hash</h4><p>Android also requires the certificate file to be named with its subject hash. Use the openssl command again to get this hash. The command is openssl x509 -inform PEM -in burp.pem -subject_hash_old -noout. The output will be a unique hexadecimal string, which is the required filename.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/584/0*nfDLOdJeNp7a9UIl" /></figure><h4>27) Rename the certificate file</h4><p>Rename the burp.pem file to the hash obtained in the previous step, adding a .0 extension. The command is cp burp.pem 9a5ba575.0 (using your specific hash). This naming convention is necessary for Android to recognize it as a valid system-trusted CA.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/352/0*Q37lQE8uQIxYaWys" /></figure><h4>28) Inspect the certificate content</h4><p>You can use the <strong>cat</strong> command to view the contents of the newly renamed PEM certificate file. This shows the certificate’s PEM-encoded data, confirming it’s ready to be pushed to the emulator.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/596/0*f4S-eglQUwzuQGWH" /></figure><h4>29) Push the certificate to the emulator and reboot</h4><p>Back on your Windows machine, use adb to gain root access and remount the system partition with write permissions. Then, <strong>push</strong> the renamed certificate file to the /system/etc/security/cacerts/ directory on the emulator. Finally, use the adb reboot command to restart the virtual device, allowing it to load the new certificate and trust it for HTTPS traffic interception.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1011/0*002VQBNUlbt1zE6m" /></figure><h4>30) Open Extended Controls</h4><p>After the emulator has rebooted, click the <strong>three dots</strong> on the right side of the emulator’s window. This opens the <strong>Extended Controls</strong> menu, which provides various settings for the virtual device.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*k5Yi39n8jYOJ7EjZ" /></figure><h4>31) Configure the Proxy Settings</h4><p>In the Extended Controls menu, navigate to the <strong>Settings</strong> tab and then select <strong>Proxy</strong>. Choose the <strong>Manual proxy configuration</strong> option. Enter the <strong>Host name</strong> and <strong>Port number</strong> for your Burp Suite listener. The standard settings are 127.0.0.1 (or your host machine’s IP address) and 8080. Click <strong>Apply</strong> to save the changes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7jYptrZmc72bvRpb" /></figure><h4>32) Test HTTPS Interception</h4><p>Open the browser on the AAOS emulator and visit a website that uses HTTPS (e.g., your personal blog or a test site). Simultaneously, observe the <strong>HTTP history</strong> tab in Burp Suite on your host machine. You should see the intercepted request appear in the list, confirming that your setup is working correctly and you can now analyze secure traffic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5BQ49dNtjAU2BLvR" /></figure><p><strong>Conclusion</strong></p><p>Congratulations! You have successfully configured a complete AAOS penetration testing environment. This setup is a powerful starting point for:</p><ul><li><strong>Static analysis:</strong> Using tools like MobSF to inspect the APK for vulnerabilities.</li><li><strong>Dynamic analysis:</strong> Using Frida to manipulate app behavior at runtime.</li><li><strong>Binary inspection:</strong> Examining the app’s files on the device for sensitive information.</li></ul><p>This is a dynamic field, and with this foundational knowledge, you are well-equipped to drive into the world of automotive application security.</p><blockquote><em>for more Contact : sv110040@gmail.com</em></blockquote><p><strong>References:</strong></p><ul><li><a href="https://source.android.com/docs/automotive/start/what_automotive">What is Android Automotive? | Android Open Source Project</a></li><li><a href="https://developer.android.com/codelabs/build-a-parked-app#0">Build and test a parked app for Android Automotive OS | Android Developers</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=29ffcab3fda9" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/step-by-step-complete-setup-guide-for-automotive-application-testing-aaos-emulator-29ffcab3fda9">Step-by-step Complete Setup Guide for Automotive Application Testing (AAOS Emulator)</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Step by Step Complete Beginners guide of iOS penetration testing]]></title>
            <link>https://infosecwriteups.com/step-by-step-complete-beginners-guide-of-ios-penetration-testing-17092c0e0dc7?source=rss-1125fd6b489d------2</link>
            <guid isPermaLink="false">https://medium.com/p/17092c0e0dc7</guid>
            <category><![CDATA[ios-hacking]]></category>
            <category><![CDATA[appsec-testing]]></category>
            <category><![CDATA[ios-penetration-testing]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[pentesting]]></category>
            <dc:creator><![CDATA[Sandeep Vishwakarma]]></dc:creator>
            <pubDate>Tue, 27 May 2025 06:15:26 GMT</pubDate>
            <atom:updated>2025-05-27T06:15:26.393Z</atom:updated>
            <content:encoded><![CDATA[<p>Greetings fellow hackers, my name is Sandy, Security Analyst and Bug bounty hunter.</p><p>As I’m presently engaged in iOS penetration testing, I’d like to relay my experiences with you, as they may prove beneficial in addressing some of the inquiries. I had difficulty getting started on resolving answers without any more introductions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/710/1*AV6WBmyrsaVqE3RELL6hsg.png" /></figure><p>Jailbreaking an iOS device allows you to bypass Apple’s restrictions and gain access to a wider range of customizations, third-party apps, and system tweaks. However, it also comes with risks, including potential security vulnerabilities and voiding your warranty. If you’re willing to proceed, follow this step-by-step guide to jailbreak your iOS device safely.</p><h3>Table of Contents</h3><h3>🔧 Part 1: Jailbreaking iOS Devices</h3><ol><li>Introduction to Jailbreaking</li><li>Types of Jailbreaks</li></ol><ul><li>Tethered Jailbreak</li><li>Semi-Tethered Jailbreak</li><li>Semi-Untethered Jailbreak</li><li>Untethered Jailbreak</li><li>Rootless Jailbreak</li></ul><p>3. Risks of Jailbreaking</p><p>4. Preparing Your Device</p><ul><li>Checking Compatibility</li><li>Backing Up Your Data</li><li>Disabling Security Features</li></ul><p>5. Jailbreaking Tools Overview (2024)</p><ul><li>Checkra1n</li><li>Unc0ver</li><li>Taurine</li><li>Dopamine</li></ul><p>6. Jailbreaking with Dopamine: Practical Demo Using 3uTools</p><p>7. Post-Jailbreak Setup</p><ul><li>Installing Tweaks and Themes</li><li>Using Package Managers (Cydia, Sileo, Zebra)</li><li>Maintaining a Safe Jailbreak</li></ul><p>8. Common Errors &amp; Troubleshooting</p><h3>🛠️ Part 2: Static Analysis of Diva.ipa</h3><ol><li>Introduction to Diva.ipa</li><li>Tools Required for Static Analysis</li></ol><ul><li>MobSF</li><li>Class-Dump</li><li>Hopper / Ghidra</li><li>strings</li><li>otool</li><li>Plist Viewers</li></ul><p>3. Unpacking and Exploring the IPA</p><p>4.Examining the File Structure</p><p>5. Analyzing the Info.plist</p><p>6. Extracting Objective-C Class Information</p><p>7. Extracting Strings for Secrets</p><p>8. Binary Analysis</p><ul><li>Encryption Flags</li><li>PIE &amp; Stack Canary</li></ul><p>9. Reverse Engineering with Hopper or Ghidra</p><p>10. Common Vulnerabilities in Diva</p><ul><li>Insecure Data Storage</li><li>Hardcoded Credentials</li><li>Insecure URL Handling</li><li>Logging &amp; Debugging Issues</li><li>Weak Cryptographic Functions</li><li>Insecure iOS Functions</li></ul><p>11. Setting Up Burp Suite for iOS Traffic Interception</p><p>12. Installing and Trusting Burp CA Certificate on iPhone</p><p>13. Capturing HTTPS Traffic Successfully</p><p>14. Conclusion</p><h3>Part 1: Understanding Jailbreaking: Types, Methods, and Risks</h3><p>Jailbreaking is the process of bypassing Apple’s software restrictions on iOS devices, allowing users to install third-party apps, customizations, and tweaks that are not available through the App Store. This practice gives users greater control over their iPhones and iPads, but it also comes with certain risks.</p><p>In this guide, we will explore:<br> ✅ Different types of jailbreaks<br> ✅ Popular jailbreaking tools<br> ✅ The advantages and risks of jailbreaking</p><h3>Types of Jailbreaks</h3><p>There are several types of jailbreaks, each with different levels of persistence and functionality. The right type for you depends on your device and iOS version.</p><h3>1. Tethered Jailbreak</h3><p>🔹 <strong>Definition:</strong> Requires the device to be connected to a computer each time it is restarted.<br> 🔹 <strong>Functionality:</strong> If the device reboots without being connected to a jailbreak tool, it will become unresponsive and require a computer to boot again.<br> 🔹 <strong>Use Case:</strong> Rarely used today due to its inconvenience.</p><p>📌 <strong>Example Tool:</strong> Old versions of <strong>RedSn0w</strong></p><h3>2. Semi-Tethered Jailbreak</h3><p>🔹 <strong>Definition:</strong> Allows the device to boot normally without a jailbreak, but jailbreak-related features will not work until reactivated via a computer.<br> 🔹 <strong>Functionality:</strong> The device can restart without crashing, but tweaks and Cydia/Sileo will be disabled until you re-jailbreak.<br> 🔹 <strong>Use Case:</strong> More user-friendly than a tethered jailbreak but still requires a computer after every reboot.</p><p>📌 <strong>Example Tools:</strong> Checkra1n (for iOS 12–14), BlackRa1n</p><h3>3. Semi-Untethered Jailbreak</h3><p>🔹 <strong>Definition:</strong> The jailbreak is lost upon reboot, but the user can re-jailbreak directly from an app without needing a computer.<br> 🔹 <strong>Functionality:</strong> After rebooting, the jailbreak must be reactivated using an app like <strong>Dopamine, Unc0ver, or Taurine</strong>.<br> 🔹 <strong>Use Case:</strong> The most commonly used jailbreak method today as it offers a balance between flexibility and security.</p><p>📌 <strong>Example Tools:</strong></p><ul><li><strong>Dopamine (iOS 15–16)</strong></li><li><strong>Unc0ver (iOS 11–14.8)</strong></li><li><strong>Taurine (iOS 14)</strong></li></ul><p>📌 <strong>Screenshot Suggestion:</strong> Show <strong>Dopamine jailbreak app interface on iPhone</strong>.</p><h3>4. Untethered Jailbreak</h3><p>🔹 <strong>Definition:</strong> A permanent jailbreak that remains active even after a reboot.<br> 🔹 <strong>Functionality:</strong> The device stays jailbroken no matter how many times it reboots, without needing any additional steps.<br> 🔹 <strong>Use Case:</strong> The most desirable jailbreak type, but very rare due to Apple’s security improvements.</p><p>📌 <strong>Example Tools:</strong></p><ul><li><strong>Absinthe (iOS 5.1.1)</strong></li><li><strong>Evasi0n (iOS 6.1.2)</strong></li><li><strong>Pangu (iOS 7–9)</strong></li></ul><p>📌 <strong>Screenshot Suggestion:</strong> Show <strong>Cydia running on an untethered jailbroken iPhone</strong>.</p><h3>5. Rootless Jailbreak</h3><p>🔹 <strong>Definition:</strong> A jailbreak that does not provide full system access, but still allows tweak installation.<br> 🔹 <strong>Functionality:</strong> Tweaks and modifications work, but system files remain untouched, making it more secure.<br> 🔹 <strong>Use Case:</strong> Ideal for users who want customizations without security risks.</p><p>📌 <strong>Example Tools:</strong></p><ul><li><strong>Dopamine (iOS 15–16, rootless version)</strong></li><li><strong>Taurine (rootless version for iOS 14)</strong></li></ul><p><strong>Popular Jailbreak Tools (2024)</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ot2MN_AjAxaFFjfq" /></figure><h3>Risks of Jailbreaking</h3><p>⚠️ <strong>Security Vulnerabilities</strong> — Jailbreaking removes Apple’s security protections, making your device more vulnerable.<br> ⚠️ <strong>App Store &amp; Banking App Issues</strong> — Some apps detect jailbreaking and refuse to work.<br> ⚠️ <strong>Device Instability</strong> — Installing too many tweaks can cause system crashes.<br> ⚠️ <strong>Bricking Risk</strong> — A failed jailbreak can render your device unusable.<br> ⚠️ <strong>Loss of Warranty</strong> — Apple does not provide support for jailbroken devices.</p><h3>Step 1: Check Device Compatibility</h3><p>Before jailbreaking, confirm that your iOS version and device are supported by the latest jailbreak tools. Some popular tools include:</p><ul><li><strong>Checkra1n</strong> (Supports iOS 12 to iOS 14.8.1 on A7-A11 devices)</li><li><strong>Unc0ver</strong> (Supports iOS 11 to iOS 14.3 on most devices)</li><li><strong>Taurine</strong> (Supports iOS 14 to iOS 14.3)</li><li><strong>Dopamine</strong> (Supports iOS 15–15.4.1 on A12+ devices)</li></ul><p>To check your iOS version, go to <strong>Settings &gt; General &gt; About</strong>.</p><h3>Step 2: Backup Your Device</h3><p>Jailbreaking involves modifying system files, which can sometimes result in errors. To avoid data loss, back up your device using iCloud or iTunes:</p><ul><li><strong>iCloud Backup:</strong> Go to <strong>Settings &gt; [Your Name] &gt; iCloud &gt; iCloud Backup &gt; Back Up Now</strong>.</li><li><strong>iTunes/Finder Backup:</strong> Connect your iPhone to a computer, open iTunes (or Finder on macOS Catalina and later), and select <strong>Back Up Now</strong>.</li></ul><h3>Step 3: Disable Passcode, Face ID, and Find My iPhone</h3><p>Some jailbreak tools require these settings to be disabled temporarily:</p><ul><li>Go to <strong>Settings &gt; Face ID &amp; Passcode &gt; Turn Off Passcode</strong>.</li><li>Go to <strong>Settings &gt; Apple ID &gt; Find My &gt; Turn Off Find My iPhone</strong>.</li></ul><h3>Step 4: Download the Jailbreak Tool</h3><p>Depending on your iOS version, download the appropriate jailbreak tool:</p><ul><li>For <strong>Checkra1n</strong>, visit<a href="https://checkra.in/"> checkra.in</a>.</li><li>For <strong>Unc0ver</strong>, download from<a href="https://unc0ver.dev/"> unc0ver.dev</a>.</li><li>For <strong>Taurine</strong>, visit<a href="https://taurine.app/"> taurine.app</a>.</li><li>For <strong>Dopamine</strong>, check<a href="https://github.com/opa334/Dopamine"> GitHub</a>.</li></ul><h3>Step 5: Install and Run the Jailbreak Tool</h3><h4>For Checkra1n (Mac/Linux) (Tethered Jailbreak)</h4><ol><li>Download and install <strong>Checkra1n</strong>.</li><li>Connect your iPhone to your computer via USB.</li><li>Open Checkra1n and click <strong>Start</strong>.</li><li>Follow on-screen instructions to enter <strong>DFU mode</strong>.</li><li>Wait for the jailbreak process to complete.</li><li>After the device reboots, open the <strong>Checkra1n app</strong> and install <strong>Cydia</strong>.</li></ol><h4>For Unc0ver/Taurine/Dopamine (Untethered/Semi-Untethered Jailbreak)</h4><ol><li>Download the jailbreak IPA file.</li><li>Install <strong>AltStore</strong> on your PC/Mac.</li><li>Connect your iPhone and use AltStore to sideload the jailbreak IPA.</li><li>Open the jailbreak app on your iPhone and tap <strong>Jailbreak</strong>.</li><li>Your device will respring, and you should see <strong>Cydia</strong> (or <strong>Sileo</strong> for Taurine/Dopamine) on your home screen.</li></ol><h3>Step 6: Install Tweaks and Customizations</h3><p>Once jailbroken, open <strong>Cydia</strong>, <strong>Sileo</strong>, or <strong>Zebra</strong> to install jailbreak tweaks, themes, and apps. Popular repositories include:</p><ul><li><strong>BigBoss</strong> (Pre-installed)</li><li><strong>Packix</strong> (repo.packix.com)</li><li><strong>Chariz</strong> (repo.chariz.com)</li><li><strong>Twickd</strong> (repo.twickd.com)</li></ul><p>Be cautious when installing tweaks, as incompatible tweaks can cause system crashes.</p><h3>Step 7: Stay Safe and Maintain Your Jailbreak</h3><ul><li><strong>Avoid iOS updates</strong>, as they can patch jailbreak exploits.</li><li><strong>Use a jailbreak detection bypass</strong> for banking and official apps.</li><li><strong>Install a package manager like Filza or iCleaner</strong> to manage system files and performance.</li><li><strong>Keep SHSH blobs saved</strong> for downgrades (use tools like TSS Saver).</li></ul><h3>Practical demonstration of jailbreak iOS Device by using Dopamine.</h3><h3>Step 1: Download 3uTools</h3><ol><li><strong>Download and install</strong> the latest version of <strong>3uTools</strong> on your PC.</li></ol><ul><li>You can get it from the official <strong>3uTools website</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WbGYhyYuF5hCruxH" /></figure><h3>Step 2: Connect Your iPhone to 3uTools</h3><ol><li><strong>Use a Lightning cable</strong> to connect your iPhone/iPad to the computer.</li><li>Open <strong>3uTools</strong> and wait for it to detect your device.</li><li>Click on <strong>“Toolbox”</strong> and select <strong>“Jailbreak”</strong>.</li><li>Select <strong>Dopamine</strong> and click on <strong>Start Jailbreak</strong>.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8Q9S8aEDEJtQ8U6Y" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Je_1gd1YutCkUE0_" /></figure><h3>Step 4: Jailbreak Using Dopamine</h3><ol><li>Open the <strong>Dopamine app</strong> on your iPhone.</li><li>Tap the <strong>“Jailbreak”</strong> button to start the process.</li><li>Your device may <strong>respring</strong> or reboot multiple times — this is normal.</li><li>Once completed, <strong>Sileo </strong>will appear on your home screen.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*i7tqjwzGqeO7Uav4" /></figure><h3>Troubleshooting Tips</h3><ul><li><strong>Dopamine won’t open?</strong> Reinstall it via 3uTools and trust the developer profile.</li><li><strong>Jailbreak failed?</strong> Restart your iPhone and try again.</li><li><strong>Jailbreak disabled after reboot?</strong> Open Dopamine and tap <strong>“Enable Jailbreak”</strong> again.</li></ul><h3>Step 6: Install Tweaks &amp; Customizations</h3><p><strong>After successfully jailbreaking, you can install powerful tweaks using Sileo.</strong></p><h4>Recommended Repositories for Tweaks</h4><p>These repositories provide access to tweaks that enhance iOS customization and functionality:</p><ol><li><strong>Untitled Repo</strong> — <a href="https://iosgod.com/repo/">https://iosgod.com/repo/</a></li><li><strong>alias20 Repo</strong> — <a href="https://alias20.gitlab.io/apt/">https://alias20.gitlab.io/apt/</a></li><li><strong>BigBoss Repo</strong> — <a href="http://apt.thebigboss.org/repofiles/cydia/">http://apt.thebigboss.org/repofiles/cydia/</a></li><li><strong>Chariz Repo</strong> — <a href="https://repo.chariz.com/">https://repo.chariz.com/</a></li><li><strong>ElleKit Repo</strong> <a href="https://ellekit.space/">— https://ellekit.space/</a></li><li><strong>Frida Repo</strong> — <a href="https://build.frida.re/">https://build.frida.re/</a></li><li><strong>Havoc Repo</strong> <a href="https://havoc.app/">— https://havoc.app/</a></li><li><strong>ichitaso Repository</strong> — <a href="https://cydia.ichitaso.com/">https://cydia.ichitaso.com/</a></li></ol><blockquote>For More tweaks : <a href="https://www.linkedin.com/posts/sandeepvishwakarma1_ios-pentesting-tools-activity-7224057627511545857-k6mP?utm_source=share&amp;utm_medium=member_desktop&amp;rcm=ACoAABiF8goBfmMRixOjijhg0wCbUgCFj_V1Mgk">https://www.linkedin.com/posts/sandeepvishwakarma1_ios-pentesting-tools-activity-7224057627511545857-k6mP?utm_source=share&amp;utm_medium=member_desktop&amp;rcm=ACoAABiF8goBfmMRixOjijhg0wCbUgCFj_V1Mgk</a></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*L-mDRZQoG9tWGOyw" /></figure><h3>How to Install Tweaks from Sileo</h3><ol><li>Open <strong>Sileo</strong> and go to the <strong>Sources</strong> tab.</li><li>Tap the <strong>+</strong> button and add the repository URLs listed above.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*432m86fOaVMKH3i5" /></figure><p>3. After adding sources, go to the <strong>Search</strong> tab and find the tweak you want.</p><p>4. Tap <strong>Get &gt; Confirm</strong> and wait for the tweak to install.</p><p>5. Respring your device if necessary.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hUlh-FXTSJ-TdX6D" /></figure><p>Jailbreaking unlocks a world of possibilities but requires careful handling. If you ever want to remove the jailbreak, simply restore your device via iTunes or Finder.</p><h3>Part 2: Static Analysis of Diva.ipa</h3><h4>Introduction</h4><p>Diva (Damn Insecure and Vulnerable App) is an intentionally vulnerable iOS application designed to help security researchers and developers understand common security flaws in iOS apps. This blog will walk you through the static analysis of Diva.ipa, identifying potential vulnerabilities and understanding how the application is structured.</p><h3>Setting Up the Environment</h3><p>Before diving into the analysis, ensure you have the following tools installed:</p><ul><li><strong>MobSF</strong> (Mobile Security Framework) — Automates static analysis.</li><li><strong>Class-Dump</strong> — Extracts Objective-C class information.</li><li><strong>Hopper or Ghidra</strong> — Reverse engineering tools for binary analysis.</li><li><strong>strings</strong> — Extracts human-readable strings from binaries.</li><li><strong>otool</strong> — Provides detailed information about Mach-O binaries.</li><li><strong>Plist Viewer</strong> — To analyze property list files.</li></ul><h3>Unpacking the IPA</h3><p>An IPA file is essentially a ZIP archive. Extract it using:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*uA5bV_4qXwKeT9Fa" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*OL-Vr6nmYUO-RdCX" /></figure><p>Inside the extracted folder, you will find the <strong>Payload</strong> directory containing the main app bundle (Diva.app).</p><h3>Exploring the File Structure</h3><p>Navigate to Diva.app, where you will find several key files:</p><ul><li><strong>Diva</strong> — The main Mach-O executable.</li><li><strong>Info.plist</strong> — Contains metadata about the application.</li><li><strong>Frameworks/</strong> — Third-party libraries used by the app.</li><li><strong>Resources/</strong> — Stores images, localizations, and other assets.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*y4ce3hscA2WNsm9J" /></figure><h3>Analyzing Info.plist</h3><p>Check for security misconfigurations using:</p><p>Look for:</p><ul><li><strong>UIFileSharingEnabled = true</strong> (May expose app data via iTunes)</li><li><strong>NSAllowsArbitraryLoads = true</strong> (Indicates insecure network configurations)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wdfIIQln2W3dVlUg" /></figure><ul><li><strong>Keychain Sharing or URL Schemes</strong> (Potential attack vectors)</li></ul><h3>Extracting Class Information</h3><p>To analyze the Objective-C class structure, use class-dump:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/579/0*3kxf3kcO35V6-NvA" /></figure><p>This generates header files revealing method names and structures, which can help in identifying sensitive functions.</p><h3>Extracting Strings</h3><p>Run strings on the binary to look for hardcoded secrets:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/464/0*haiZgaMtlavvodMO" /></figure><p>This might reveal sensitive information such as API keys, URLs, or credentials.</p><h3>Binary Analysis</h3><h3>Checking Security Flags</h3><p>Use otool to verify security mitigations:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/774/0*QbYOtstDHkvy13T_" /></figure><ul><li>If cryptid is <strong>0</strong>, the binary is decrypted.</li><li>If cryptid is <strong>1</strong>, it is encrypted (not suitable for static analysis without decryption).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EK1FBvXtCKA9XxNs" /></figure><p>Check ASLR and PIE:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/413/0*KKIK8_vF0_9Of6-a" /></figure><p>Look for <strong>PIE enabled</strong> and <strong>Stack Canary</strong> to check if basic security mechanisms are implemented.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sF3EAhVCO6avW8rf" /></figure><h3>Reverse Engineering with Hopper/Ghidra</h3><p>Load Diva into Hopper or Ghidra to analyze functions, decompiled code, and control flow. Focus on:</p><ul><li><strong>Sensitive API calls</strong> (e.g., NSLog, NSUserDefaults, Keychain)</li><li><strong>Cryptographic operations</strong> (Weak encryption or hardcoded keys)</li><li><strong>Inter-process communication (IPC) vulnerabilities</strong></li></ul><h3>Identifying Vulnerabilities</h3><h3>1. Insecure Data Storage</h3><p>Check if sensitive data is stored in <strong>NSUserDefaults</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Bq-VlCGnyQ7tUvN8" /></figure><p>This is insecure as it can be extracted easily.</p><h3>2. Hardcoded Credentials</h3><p>Identify hardcoded secrets in strings:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/574/0*tmHoWF5R09o9cNdQ" /></figure><h3>3. Insecure URL Handling</h3><p>Check for custom URL schemes that can be exploited:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bM2ZUdYU1iyUJyWz" /></figure><p>This could allow an attacker to open the app with malicious parameters.</p><h3>4. Debugging and Logging Issues</h3><p>Check for debug flags:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/589/0*tMqOad51aykH_yAi" /></figure><p>The presence of debugging flags or logging statements (NSLog) may leak sensitive data.</p><h3>5. Weak Cryptographic Functions</h3><h4>Usage of weak or outdated cryptographic algorithms like MD5, SHA-1, or DES makes the app vulnerable to attacks:</h4><p>Check for MD5, SHA-1 (Weak Hashing Algorithms)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/737/0*wajrD5dIrPBT3FOm" /></figure><ul><li><strong>MD5</strong> is vulnerable to collision attacks.</li><li><strong>SHA-1</strong> is deprecated due to weaknesses in hashing.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*h7avpNOQ3tgPb_pz" /></figure><p><strong>6. Insecure and Vulnerable function</strong></p><p>Certain functions in iOS/macOS development are considered insecure because they can lead to <strong>buffer overflows, memory corruption, command injection, or unintended behavior</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*NCVY8hiIZ_TBiequ" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kllNAFP0SJDWH__G" /></figure><p><strong>Setup Burp Suite for Analysis</strong></p><p>At this stage, the steps for setting up Burp Suite are similar to the ones mentioned earlier, namely:</p><p>1) Start Burp Suite</p><p>2) Click on the “Proxy” tab</p><p>3) Click on “Intercept is on” button</p><p>4) Click on “Options” tab</p><p>5) Under Proxy Listeners click on “10.11.3.4:8080” and click edit</p><p>6) Select the “Specific address” radio button and then click “OK.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8gmgFHnU7WePUP8w" /></figure><p>7) Click on “Yes” to the listen on Specific address warning dialog</p><p>8) Click on the “HTTP History” tab</p><p>9) Open the “Settings” app on iOS device.</p><p>10) tap on “Wi-Fi”</p><p>11) Tap on the “i” button next to the “WIFI_NAME” Wi-Fi network.</p><p>12) tap on “Configure Proxy”</p><p>13) tap on “Manual”</p><p>14) tap on “Server” and enter the IP address, in my case this is “192.168.1.35”</p><p>15) Touch “Port,” input “8080,” and then tap “Save.”</p><p>16) Tap the home button to return to the main screen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GxsPsbCqI2UtnI_f" /></figure><h3>Installing the PortSwigger CA Certificate on iPhone</h3><p>Follow these steps to download and install the PortSwigger CA certificate for Burp Suite on your iPhone:</p><h4>Step 1: Download the Certificate</h4><ol><li>Open <strong>Safari</strong> on your iPhone.</li><li>Navigate to Burp Suite’s <strong>CA Certificate</strong> page by typing <a href="http://burp./">http://burp.</a></li><li>A prompt will appear: <em>“This website is trying to download a configuration profile. Do you want to allow this?”</em></li><li>Tap <strong>Allow</strong> to proceed.</li><li>A confirmation message will appear stating that the profile has been downloaded. Tap <strong>Close</strong>.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*AqXGQvNduMekam9I" /></figure><h4>Step 2: Install the Certificate</h4><ol><li>Open the <strong>Settings</strong> app on your iPhone.</li><li>Tap <strong>Profile Downloaded</strong> (located below your Apple ID).</li><li>On the <strong>Install Profile</strong> screen, review the details of the <strong>PortSwigger CA</strong> certificate.</li><li>Tap <strong>Install</strong> in the top right corner.</li><li>A warning will appear stating that the certificate is an <strong>Unmanaged Root Certificate</strong> and must be manually trusted.</li><li>Tap <strong>Install</strong> again to confirm.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VaQu062Xw2FZQ5S1" /></figure><h4>Step 3: Enable the Certificate</h4><ol><li>Go to <strong>Settings &gt; General &gt; About &gt; Certificate Trust Settings</strong>.</li><li>Locate <strong>PortSwigger CA</strong> and toggle the switch to enable it.</li><li>Confirm the action if prompted.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*fGK_tvhelFo6cS2_" /></figure><h4>Step 4: Verify Traffic in Burp Suite</h4><ol><li>Open <strong>Burp Suite</strong> on your computer.</li><li>Ensure <strong>Intercept</strong> is <strong>ON</strong> under the <strong>Proxy &gt; Intercept</strong> tab.</li><li>On your iPhone, open <strong>Safari</strong> or any app that uses the internet.</li><li>Visit a website (e.g., <a href="http://example.com)./">http://example.com).</a></li><li>If everything is set up correctly, you should see the request appear in Burp Suite’s <strong>HTTP history</strong>.</li></ol><p>🎉 <strong>Success!</strong> You are now capturing your iPhone’s network traffic in Burp Suite. If HTTPS traffic isn’t intercepted, double-check that the <strong>PortSwigger CA certificate</strong> is installed and trusted.</p><blockquote>For personalized training Contact : sv110040@gmail.com</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*IjUbRvW-IMxk7mWj" /></figure><p><strong>Conclusion</strong></p><p>I spent a few days scratching my head to figure all this out. This document is like my cheat sheet for the future because I know I’ll forget all these little steps. I’m happy to share it with everyone! It helps you set up an iOS testing environment for people who test security and find bugs.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=17092c0e0dc7" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/step-by-step-complete-beginners-guide-of-ios-penetration-testing-17092c0e0dc7">Step by Step Complete Beginners guide of iOS penetration testing</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Frida on Non-Jailbroken iOS Device with Xcode Mounting]]></title>
            <link>https://osintteam.blog/frida-on-non-jailbroken-ios-device-with-xcode-mounting-17bc3f1bd406?source=rss-1125fd6b489d------2</link>
            <guid isPermaLink="false">https://medium.com/p/17bc3f1bd406</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[ios-testing]]></category>
            <category><![CDATA[pentesting]]></category>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[Sandeep Vishwakarma]]></dc:creator>
            <pubDate>Fri, 28 Mar 2025 01:35:21 GMT</pubDate>
            <atom:updated>2025-03-28T01:35:21.763Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Nqs9OA77_7qx3YHJsXaGuQ.png" /></figure><p>Greetings fellow hackers, my name is Sandy, Security Analyst and Bug bounty hunter.</p><p>As I’m presently engaged in iOS penetration testing, I’d like to relay my experiences with you, as they may prove beneficial in addressing some of the inquiries. I had difficulty getting started on resolving answers without any more introductions.</p><p>Frida is a powerful tool for reverse engineering and app security testing. But using it on a <strong>non-jailbroken iPhone</strong> can be tricky because you cannot install the Frida server directly. However, we can <strong>mount the iOS device using Xcode</strong> and use <strong>Frida Gadget</strong> to analyze apps. In this guide, I’ll show you how to do this step by step.</p><h3>Step 1: Connect and Mount iPhone in Xcode</h3><p>To communicate with a non-jailbroken iPhone, we need to mount it using Xcode.</p><h3>1. Connect iPhone to Mac</h3><ul><li>Use a <strong>Lightning or USB-C cable</strong> to connect your iPhone to your Mac.</li><li>Open <strong>Xcode</strong> and go to <strong>Window &gt; Devices and Simulators</strong>.</li><li>If your iPhone asks for <strong>Trust this computer?</strong>, tap <strong>Trust</strong>.</li></ul><h3>2. Mount Developer Disk Image (DDI)</h3><p>Xcode automatically mounts the required <strong>Developer Disk Image</strong>. But if it fails:</p><ul><li>Go to: /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/DeviceSupport/</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OMP9Izb5MZI0u0HWOaHs-A.png" /></figure><ul><li>Download the <strong>correct iOS version</strong> Developer Disk Image manually and place it in the folder.</li></ul><blockquote><a href="https://github.com/mspvirajpatel/Xcode_Developer_Disk_Images/releases">https://github.com/mspvirajpatel/Xcode_Developer_Disk_Images/releases</a></blockquote><ul><li>Restart Xcode and check if the device is mounted.</li></ul><h3>3. Confirm the Mounting</h3><p>To check if the mount is successful, open <strong>Terminal</strong> and run:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/0*47rHfDzRj-WAWBIo" /></figure><p>If you see some files listed, the device is mounted correctly!</p><h3>Step 2: Install and Use Frida Without Jailbreak</h3><p>Since we cannot install <strong>Frida Server</strong> directly, we will use <strong>Frida Gadget</strong>.</p><h3>1. Install Frida on Mac</h3><p>First, install Frida on your Mac:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/429/0*hALDD5RWn-qfjQz3" /></figure><h3>2. Inject Frida Gadget into the App</h3><ul><li>Download the <strong>Frida Gadget.dylib</strong> from the Frida official website.</li><li>Extract the target app’s <strong>IPA file</strong>.</li><li>Inject <strong>Frida Gadget</strong> into the app binary.</li><li>Re-sign the app using ldid or codesign.</li><li>Install the modified app on your iPhone via <strong>Xcode or AltStore</strong>.</li></ul><h3>3. Attach Frida to the App</h3><p>Once the app is installed, connect Frida to the running app:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/463/0*rx5obhFybAN9thMF" /></figure><p>Now, you can run Frida scripts on the non-jailbroken iPhone!</p><h3>Step 3: Use SSH Over USB (Alternative Method)</h3><p>If Xcode mounting does not work, you can try <strong>SSH over USB</strong>.</p><h3>1. Install iproxy</h3><p>brew install usbmuxd</p><h3>2. Create a Tunnel</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/456/0*0ASDW30vTDSXgZxq" /></figure><p>Now, you have a working SSH connection to the iPhone!</p><h3>Conclusion</h3><p>Using Frida on a non-jailbroken iPhone requires some extra steps, but it is possible. By mounting the device via Xcode, injecting <strong>Frida Gadget</strong>, and using SSH tunneling, you can perform app security testing without jailbreaking your iPhone.</p><p>Try it out and let me know if you have any questions! 🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=17bc3f1bd406" width="1" height="1" alt=""><hr><p><a href="https://osintteam.blog/frida-on-non-jailbroken-ios-device-with-xcode-mounting-17bc3f1bd406">Frida on Non-Jailbroken iOS Device with Xcode Mounting</a> was originally published in <a href="https://osintteam.blog/">OSINT Team</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Step-by-Step Complete Beginners guide of Wi-Fi Hacking]]></title>
            <link>https://infosecwriteups.com/wi-fi-hacking-4d9aa3ded7fd?source=rss-1125fd6b489d------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d9aa3ded7fd</guid>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[wifi]]></category>
            <category><![CDATA[wifihacking]]></category>
            <category><![CDATA[wireless]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <dc:creator><![CDATA[Sandeep Vishwakarma]]></dc:creator>
            <pubDate>Thu, 30 Jan 2025 18:18:50 GMT</pubDate>
            <atom:updated>2025-01-31T10:08:05.468Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XhR0biqDijHqgN1S" /></figure><p>Greetings, fellow security professionals! I’m Sandy, a Security Analyst and Bug Bounty Hunter, with a focus on wireless network security. I specialize in identifying and exploiting vulnerabilities in Wi-Fi networks to enhance overall security and protect against potential threats.</p><p>Wi-Fi networks have become safer over time. Most use <strong>WPA2-PSK</strong> (Wi-Fi Protected Access 2 — Pre-Shared Key) with <strong>AES encryption</strong> for security. But no security system is perfect.</p><p>One weakness of <strong>WPA2-PSK</strong> is that when a device connects to Wi-Fi, the <strong>password (in encrypted form)</strong> is shared using a <strong>4-way handshake</strong>. Hackers can <strong>capture this handshake</strong> and try to <strong>crack the password</strong> using a wordlist (a list of common passwords).</p><p>There are other ways to break Wi-Fi passwords, but using a wordlist is the <strong>simplest and most popular</strong> method used by attackers.</p><p><strong>Understanding 2.4 GHz and 5 GHz Wi-Fi</strong></p><p>Wi-Fi networks work on two frequency bands:</p><ul><li><strong>2.4 GHz</strong> (longer range, but slower speed)</li><li><strong>5 GHz</strong> (shorter range, but faster speed)</li></ul><p>A device can only connect to a Wi-Fi network if it <strong>supports the same frequency</strong>. For example, if a Wi-Fi network uses <strong>5 GHz</strong>, your device must also support <strong>5 GHz</strong> to connect.</p><p>Some Wi-Fi adapters can <strong>capture network traffic</strong> on a specific frequency if they support that band.</p><h3>Managed Mode vs. Monitor Mode</h3><p>Wi-Fi network cards (NICs) can work in two modes:</p><h4>1. Managed Mode (Normal Mode)</h4><ul><li>This is the <strong>default mode</strong> of a Wi-Fi adapter.</li><li>The device <strong>connects to Wi-Fi</strong> like a normal user.</li><li>It can <strong>send and receive</strong> data but <strong>cannot</strong> capture network traffic.</li></ul><h4>2. Monitor Mode (Sniffing Mode)</h4><ul><li>This mode allows the device to <strong>capture all nearby Wi-Fi traffic</strong> on a specific channel.</li><li>The device <strong>does not connect</strong> to any Wi-Fi network.</li><li>Used for <strong>Wi-Fi security testing, monitoring, and troubleshooting</strong>.</li></ul><p>To switch from <strong>Managed Mode</strong> to <strong>Monitor Mode</strong>, the Wi-Fi adapter <strong>must support it</strong>, and the user has to activate it using special tools. While in <strong>Monitor Mode</strong>, the device <strong>cannot</strong> connect to Wi-Fi normally.</p><h3>How to Check Wi-Fi Mode in Linux</h3><p>To check the current mode of your Wi-Fi adapter, open a terminal and run this command:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/860/0*R2VIFit3xvcIzBIS" /></figure><p>To activate <strong>Monitor Mode</strong> on a wireless NIC in Linux, we use the <strong>airmon-ng</strong> tool. Open a terminal and run the following command, replacing “wlan1” with the name of your wireless NIC:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/977/0*LmDkdwKXsB9HEZ9-" /></figure><p>This command creates a <strong>new virtual interface</strong> on your Wi-Fi adapter for <strong>Monitor Mode</strong>. You can use this interface to <strong>capture Wi-Fi traffic</strong> with tools like <strong>Wireshark</strong> or <strong>tcpdump</strong>.</p><p><strong>Things to Remember:</strong></p><ul><li>You need <strong>admin (root) access</strong>, so you might be asked for your password.</li><li><strong>Disconnect</strong> from any Wi-Fi networks before enabling Monitor Mode to avoid issues.</li></ul><p>To check if your Wi-Fi card is in Monitor Mode, run this command:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/874/0*j71G019cmmtU-IGd" /></figure><p><strong>Packet sniffing</strong> with <strong>airodump-ng</strong> is a common method to <strong>capture and analyze Wi-Fi traffic</strong> in real-time. <strong>Airodump-ng</strong> is a command-line tool that comes with the <strong>Aircrack-ng</strong> suite.</p><p>To use <strong>airodump-ng</strong>, open a terminal and run:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jBEBg0w06yA7Lrvq" /></figure><p>This command starts <strong>airodump-ng</strong> in <strong>Monitor Mode</strong>, using the virtual interface <strong>wlan0mon</strong> (created by airmon-ng). It scans Wi-Fi traffic and displays details about detected <strong>Access Points (APs)</strong> and <strong>clients</strong>.</p><h3>Key Terms:</h3><ul><li><strong>BSSID:</strong> The unique MAC address of the router/AP.</li><li><strong>PWR:</strong> Signal strength (higher means closer).</li><li><strong>Beacons:</strong> Packets sent by the AP to announce its presence.</li><li><strong># Data:</strong> Number of captured data packets.</li><li><strong>MB:</strong> Maximum data rate of the AP.</li><li><strong>CIPHER:</strong> Encryption type used on the network.</li><li><strong>ESSID:</strong> The Wi-Fi network name.</li></ul><h3>Targeted Packet Sniffing:</h3><p>Instead of capturing all traffic, you can <strong>focus on specific packets</strong>, such as authentication requests or packets from a specific AP or client.</p><p>To capture traffic from a <strong>specific AP</strong> on <strong>channel 6</strong>, use:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/625/0*gPeCnlSOkaC-J2LI" /></figure><p>Once you have captured the targeted packets, you can <strong>analyze</strong> them using tools like <strong>Wireshark</strong> or <strong>tcpdump</strong> to find patterns or specific packets of interest.</p><p>The captured packets are stored in a file named <strong>“Rishab-4G”</strong>, which you can open in Wireshark for detailed inspection.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/0*hhaPQuPcmHpJAw3p" /></figure><p>A <strong>Deauthentication Attack</strong> disconnects a target client or access point by sending <strong>deauthentication packets</strong> using the <strong>aireplay-ng</strong> tool.</p><p>To send deauth packets, use the following command:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/678/0*4f8sUjeM8Mhoo9J_" /></figure><p>Replace <strong>&lt;num_deauth_packets&gt;</strong> with the number of deauthentication packets you want to send, <strong>&lt;access_point_mac&gt;</strong> with the MAC address of the access point, <strong>&lt;client_mac&gt;</strong> with the MAC address of the target client, and <strong>&lt;interface&gt;</strong> with your wireless interface name.</p><p>Next, use <strong>aircrack-ng</strong> to crack the captured WPA handshake by performing a wordlist attack on the 4-way handshake.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/0*6h69YyHpVyloheFf" /></figure><p>Replace &lt;wordlist_file&gt; with your wordlist’s file path and &lt;capture_file&gt; with the path to the captured traffic file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/427/0*8Fyfvcydlj0EHbNm" /></figure><p>Crack a “WPA handshake” using “hashcat” to break the captured 4-way handshake with a wordlist attack:</p><p><strong>hcxtools</strong> is a set of tools for capturing and converting wireless network packets for password cracking. One of these tools, <strong>hcxtool</strong>, captures and saves EAPOL frames, which are part of the WPA/WPA2 authentication process. These frames contain important data like the <strong>PMKID (Pairwise Master Key Identifier)</strong>, which can be used for offline password cracking.</p><p>Follow these steps to convert a capture file (<strong>.cap</strong>) into a format compatible with <strong>Hashcat</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*D32u4ZU6VsWIyXtV" /></figure><p>Capture the Handshake: Use a tool like <strong>airodump-ng</strong> to capture the WPA/WPA2 handshake and save it as a <strong>.cap</strong> file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/0*xqSHSqH4U97KfL2q" /></figure><p><strong>Convert the .cap to Hashcat’s format:</strong></p><p>Run the following command to convert the <strong>.cap</strong> file into a format compatible with <strong>Hashcat</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*iYHs7DQb7_mI9-e6" /></figure><p>In this command, <strong>capture-02.cap</strong> is the input file in <strong>.cap</strong> format, and <strong>-o</strong> specifies the output file in <strong>.txt</strong> format.</p><blockquote>For personalize training Contact : sv110040@gmail.com</blockquote><p><strong>Use Hashcat to Crack the Password:<br></strong>Once you have the <strong>hashcat.txt</strong> file, use <strong>Hashcat</strong> to crack the password. You’ll need a <strong>wordlist</strong> and a <strong>compatible Hashcat version</strong> for this.</p><p>Here’s an example command to run <strong>Hashcat</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/638/0*5MKgIlSzL9EonBhm" /></figure><p><strong>Wait for Hashcat to Crack the Password:<br></strong>The time required depends on the password strength and your computer’s processing power. Hashcat may take hours or even days to complete.</p><p>You can monitor the progress on the screen. Once Hashcat successfully cracks the password, it will display the result.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9MefdFZkkoAzmmgH" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d9aa3ded7fd" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/wi-fi-hacking-4d9aa3ded7fd">Step-by-Step Complete Beginners guide of Wi-Fi Hacking</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pentesting Large Language Model Applications and AI Decoy Bypass]]></title>
            <link>https://infosecwriteups.com/pentesting-large-language-model-applications-and-ai-decoy-bypass-140e1f50db3c?source=rss-1125fd6b489d------2</link>
            <guid isPermaLink="false">https://medium.com/p/140e1f50db3c</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[pentesting]]></category>
            <category><![CDATA[llm-applications]]></category>
            <dc:creator><![CDATA[Sandeep Vishwakarma]]></dc:creator>
            <pubDate>Tue, 30 Jul 2024 18:27:29 GMT</pubDate>
            <atom:updated>2024-07-30T18:27:29.611Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jc4-Ttf34BIDbuQrSqdIow.png" /></figure><p>Greetings fellow hackers, my name is Sandy, Information Security Consultant and Bug bounty hunter.</p><p>As I’m presently engaged in LLM penetration testing, I’d like to relay my experiences with you, as they may prove beneficial in addressing some of the inquiries, I had difficulty resolving answers too, without more introductions let’s get started.</p><p>Large Language Models (LLMs) represent a groundbreaking advancement in artificial intelligence, capable of generating human-like text based on vast datasets and complex algorithms. However, alongside their transformative potential, deploying LLMs introduces unique security challenges that require careful consideration and robust mitigation strategies. The OWASP Top 10 for Large Language Model Applications version 1.1 identifies critical vulnerabilities specific to these advanced AI systems, aiming to guide organizations in securing their implementations effectively.</p><h4>1. LLM01: Prompt Injection</h4><p><strong>Introduction:</strong> Prompt injection refers to the manipulation of LLM behavior through crafted inputs, potentially leading to unauthorized access, data breaches, and compromised decision-making processes. This vulnerability underscores the necessity of stringent input validation and robust security controls to manage interactions with LLMs securely.</p><p><strong>Scenario:</strong> Consider a scenario where a financial institution integrates an LLM into its customer support system. An attacker exploits prompt injection by crafting prompts designed to extract sensitive customer information, such as account numbers or transaction details. By manipulating the LLM’s responses, the attacker could gain unauthorized access to financial data, resulting in financial losses for customers and legal liabilities for the institution.</p><p><strong>Mitigation Strategies:</strong></p><ul><li>Implement rigorous input validation mechanisms to sanitize and filter user inputs effectively.</li><li>Utilize context-aware processing to detect and mitigate anomalous or potentially malicious prompts.</li><li>Enforce strict access controls to restrict LLM responses based on user privileges and the sensitivity of the information.</li></ul><h4>2. LLM02: Insecure Output Handling</h4><p><strong>Introduction:</strong> Insecure output handling occurs when LLM outputs are not adequately validated or sanitized before being utilized in downstream systems or presented to users. This vulnerability can lead to various exploits, including code execution, cross-site scripting (XSS) attacks, and unintended data leakage.</p><p><strong>Scenario:</strong> An e-commerce platform utilizes an LLM to generate product descriptions dynamically. Due to insufficient validation, the LLM outputs may contain HTML or JavaScript code that, when rendered on the website, triggers XSS vulnerabilities. Exploiting this, attackers could compromise user sessions, inject malicious scripts, or redirect users to phishing websites, severely compromising the platform’s security and integrity.</p><p><strong>Mitigation Strategies:</strong></p><ul><li>Implement robust output sanitization routines to remove or neutralize potentially harmful content from LLM outputs.</li><li>Validate and encode LLM-generated content according to the specific context and intended use within the application.</li><li>Conduct regular security audits and penetration testing to identify and mitigate vulnerabilities associated with output handling processes.</li></ul><h4>3. LLM03: Training Data Poisoning</h4><p><strong>Introduction:</strong> Training data poisoning involves manipulating the datasets used to train LLMs, introducing biases, inaccuracies, or vulnerabilities into the model’s behavior. This vulnerability can significantly impact the reliability, accuracy, and ethical implications of LLM outputs.</p><p><strong>Scenario:</strong> In the healthcare sector, an LLM assists in diagnosing patients based on electronic health records. An adversary poisons the LLM’s training data by injecting misleading or biased information, causing the model to generate incorrect diagnoses or inadvertently reveal sensitive patient information. Such attacks compromise patient confidentiality, undermine medical decisions, and expose healthcare providers to legal liabilities.</p><p><strong>Mitigation Strategies:</strong></p><ul><li>Implement rigorous data validation and cleansing procedures to identify and mitigate instances of poisoned training data.</li><li>Utilize diverse and representative datasets during LLM training to reduce the impact of biased or manipulated inputs.</li><li>Deploy explainable AI techniques to enhance transparency and mitigate the effects of data poisoning on LLM behavior.</li></ul><h4>4. LLM04: Model Denial of Service</h4><p><strong>Introduction:</strong> Model denial of service (DoS) occurs when malicious actors overload LLMs with excessive requests or resource-intensive operations, leading to degraded performance or complete service disruption. This vulnerability poses significant operational and financial risks for organizations relying on LLMs for critical tasks.</p><p><strong>Scenario:</strong> A cloud-based LLM service provider becomes a target of a coordinated distributed denial of service (DDoS) attack orchestrated by multiple adversaries. The attackers flood the LLM infrastructure with a massive volume of requests, depleting computational resources and causing prolonged downtime. Consequently, legitimate users are unable to access essential services, resulting in financial losses and damaging the provider’s reputation.</p><p><strong>Mitigation Strategies:</strong></p><ul><li>Implement robust rate limiting and throttling mechanisms to control the volume of requests processed by LLMs.</li><li>Deploy scalable and resilient infrastructure capable of dynamically adjusting resources based on demand spikes and traffic patterns.</li><li>Monitor LLM performance metrics rigorously to detect and mitigate abnormal traffic indicative of DoS attacks promptly.</li></ul><h4>5. LLM05: Supply Chain Vulnerabilities</h4><p><strong>Introduction:</strong> Supply chain vulnerabilities in LLMs encompass risks associated with compromised components, services, or datasets integrated into the model’s development or deployment pipeline. These vulnerabilities can lead to data breaches, system failures, and unauthorized access to sensitive information.</p><p><strong>Scenario:</strong> An educational institution adopts an LLM-powered learning management system (LMS) relying on third-party libraries and data sources for model training and operation. However, a compromised third-party library used by the LLM introduces vulnerabilities, enabling attackers to exploit weaknesses and gain unauthorized access to student data. Such incidents compromise student privacy, breach regulatory compliance, and tarnish the institution’s reputation.</p><p><strong>Mitigation Strategies:</strong></p><ul><li>Conduct comprehensive security assessments and due diligence when selecting third-party components and datasets for LLM development.</li><li>Enforce secure coding practices and stringent access controls to mitigate risks introduced by vulnerable supply chain elements.</li><li>Establish robust contingency plans and rapid response protocols to address supply chain incidents promptly and effectively.</li></ul><h4>6. LLM06: Sensitive Information Disclosure</h4><p><strong>Introduction:</strong> Sensitive information disclosure occurs when LLM outputs inadvertently expose confidential or proprietary data that should be protected from unauthorized access or disclosure. This vulnerability can lead to legal liabilities, loss of competitive advantage, and erosion of organizational trust.</p><p><strong>Scenario:</strong> A legal firm deploys an LLM to automate the generation of legal documents, including contracts and case briefs. Due to inadequate data filtering or redaction mechanisms, the LLM includes confidential client information in its outputs, which are then shared with opposing counsel. Such inadvertent disclosure compromises client confidentiality, undermines legal strategies, and exposes the firm to regulatory penalties.</p><p><strong>Mitigation Strategies:</strong></p><ul><li>Implement robust data masking and redaction techniques to prevent unintended disclosure of sensitive information in LLM outputs.</li><li>Employ encryption and stringent access controls to safeguard confidential data throughout its lifecycle, from generation to distribution.</li><li>Conduct regular audits and compliance assessments to ensure adherence to data protection regulations and industry standards.</li></ul><h4>7. LLM07: Insecure Plugin Design</h4><p><strong>Introduction:</strong> Insecure plugin design vulnerabilities arise when LLMs integrate third-party plugins or extensions that process untrusted inputs without adequate access controls or security safeguards. These vulnerabilities can facilitate exploits such as remote code execution, unauthorized data access, and compromise of system integrity.</p><p><strong>Scenario:</strong> A social media platform allows third-party developers to create plugins for an LLM-driven content moderation system. A malicious plugin developer embeds code exploiting vulnerabilities in the LLM’s input processing routines. Consequently, the compromised plugin gains unauthorized access to user data, manipulates content moderation decisions, and spreads malicious content across the platform. Such incidents undermine user trust, compromise platform integrity, and expose users to security risks.</p><p><strong>Mitigation Strategies:</strong></p><ul><li>Implement rigorous security vetting and validation processes for third-party plugins and extensions integrated into LLM environments.</li><li>Enforce the principle of least privilege by restricting plugin capabilities and access rights based on functional requirements and security policies.</li><li>Establish continuous monitoring, vulnerability assessment, and rapid response mechanisms to mitigate risks associated with insecure plugin design.</li></ul><h4>8. LLM08: Excessive Agency</h4><p><strong>Introduction:</strong> Excessive agency vulnerabilities in LLMs arise when autonomous decision-making capabilities are granted without adequate oversight or control mechanisms. This vulnerability can lead to unintended consequences, ethical dilemmas, and risks to privacy, reliability, and trustworthiness.</p><p><strong>Scenario:</strong> An autonomous vehicle employs an LLM for real-time decision-making in dynamic traffic scenarios. Due to excessive autonomy granted to the LLM, the vehicle prioritizes speed over safety, making decisions that compromise pedestrian safety and violate traffic regulations. As a result, accidents occur, leading to injuries and legal liabilities for the vehicle manufacturer. Such incidents erode public confidence in autonomous systems, breach regulatory compliance, and raise ethical concerns surrounding AI-driven technologies.</p><p><strong>Mitigation Strategies:</strong></p><ul><li>Establish robust governance frameworks and ethical guidelines for deploying AI, including LLMs involved in critical decision-making processes.</li><li>Integrate human oversight and intervention mechanisms to review and validate LLM decisions in real-time scenarios.</li><li>Conduct comprehensive risk assessments, scenario testing, and simulations to evaluate the potential impact of LLM-driven decisions on safety, privacy, and societal well-being.</li></ul><blockquote><em>for more Contact : sv110040@gmail.com</em></blockquote><h4>9. LLM09: Overreliance</h4><p><strong>Introduction:</strong> Overreliance vulnerabilities occur when organizations excessively depend on LLM outputs without critical assessment or validation, leading to compromised decision-making, security vulnerabilities, and legal liabilities.</p><p><strong>Scenario:</strong> A governmental agency relies exclusively on an LLM-powered predictive analytics model to formulate economic policies and allocate resources. However, external actors manipulate the model’s training data or inputs, influencing the accuracy and reliability of its predictions. Consequently, the agency makes flawed decisions based on manipulated information, resulting in economic instability, public discontent, and regulatory scrutiny. Such incidents underscore the risks of overreliance on LLM outputs without rigorous validation and contextual understanding.</p><p><strong>Mitigation Strategies:</strong></p><ul><li>Establish multidisciplinary teams comprising domain experts, data scientists, and ethicists to evaluate and interpret LLM outputs across diverse contexts.</li><li>Implement transparent and explainable AI techniques to enhance understanding and trust in LLM-driven decision-making processes.</li><li>Foster a culture of critical thinking and continuous learning within organizations to mitigate biases, inaccuracies, and vulnerabilities associated with overreliance on LLM outputs.</li></ul><h4>10. LLM10: Model Theft</h4><p><strong>Introduction:</strong> Model theft vulnerabilities involve unauthorized access to proprietary LLMs, including their source code, training data, and intellectual property. This vulnerability can lead to theft of competitive advantage, dissemination of sensitive information, and misuse of AI-driven technologies by malicious actors.</p><p><strong>Scenario:</strong> A tech company develops an advanced LLM for natural language processing, utilizing proprietary algorithms and datasets. However, a competitor infiltrates the company’s network and steals the LLM’s source code, compromising its proprietary technology and market position. Subsequently, the stolen LLM technology is reverse-engineered, replicated, or misused by competitors, undermining the original developer’s competitive edge and intellectual property rights.</p><p><strong>Mitigation Strategies:</strong></p><ul><li>Implement robust access controls, encryption techniques, and digital rights management mechanisms to protect proprietary LLM assets from unauthorized access and theft.</li><li>Establish legal frameworks, non-disclosure agreements, and intellectual property protections to safeguard LLM source code, algorithms, and datasets.</li><li>Monitor network activities, data access patterns, and system logs rigorously to detect and respond promptly to unauthorized attempts to access or steal proprietary LLM assets.</li></ul><h3>Conclusion</h3><p>The OWASP Top 10 for Large Language Model Applications version 1.1 provides a comprehensive framework for identifying and mitigating critical security vulnerabilities specific to LLMs. By understanding these vulnerabilities and implementing robust security measures, organizations can enhance the resilience, reliability, and trustworthiness of LLM deployments across various domains. As LLM capabilities continue to evolve, ongoing research, collaboration, and adherence to best practices in AI ethics and cybersecurity are crucial to mitigate risks effectively and maximize the benefits of these transformative technologies.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=140e1f50db3c" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/pentesting-large-language-model-applications-and-ai-decoy-bypass-140e1f50db3c">Pentesting Large Language Model Applications and AI Decoy Bypass</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Static Testing of iOS Applications]]></title>
            <link>https://infosecwriteups.com/static-testing-of-ios-applications-cb09bd8f2927?source=rss-1125fd6b489d------2</link>
            <guid isPermaLink="false">https://medium.com/p/cb09bd8f2927</guid>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[static-code-analysis]]></category>
            <dc:creator><![CDATA[Sandeep Vishwakarma]]></dc:creator>
            <pubDate>Thu, 30 May 2024 03:33:37 GMT</pubDate>
            <atom:updated>2024-06-05T05:13:13.554Z</atom:updated>
            <content:encoded><![CDATA[<p>Greetings fellow hackers, my name is Sandy, Security Analyst and Bug bounty hunter.</p><p>As I’m presently engaged in iOS penetration testing, I’d like to relay my experiences with you, as they may prove beneficial in addressing some of the inquiries. I had difficulty getting started on resolving answers without any more introductions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/0*xQyVQAQvA1D6fr9S" /></figure><p>This guide is an extensive guide that will take you through the entire process, as well as providing an outline of what Mobile Security Framework or <a href="https://github.com/MobSF/Mobile-Security-Framework-MobSF">MobSF</a> is and how it may be used to automatically analyses an IPA file and the process of how we might hand evaluate a sample IPA file on a jailbroken iPhone. Sticking with examination, it also embraces some routine checks: The trial balances of the Info and its subsidiaries as of 31 December are as follows: Accountants checks from the Info. plist file according to various applications needs and security measures.</p><p>Based on the above points, one is left with no option than to agree that there is need for better understanding of the IPA file structure.</p><p>IPA is as of now the common form used in supplying iOS applications referring to iOS App Store Package. It is azagzipped set of files that holds all the information needed by an application to run on an iPhone. Here’s a detailed breakdown of the components found within an IPA file:Below are the features you are likely to stumble upon as you work with an IPA file:</p><p>It includes the following parts:</p><p>1. <strong>.app Directory:</strong></p><p>This is the main directory inclusive of the executable and all materials required to run the app.</p><p>To get a glimpse of the contents, modify the ‘. ’The files with ipa file extension should now be saved with . zip and decompress it.</p><p>2. <strong>Info. plist:</strong></p><p>This file has important property constraints which include the app’s bundle ID, version number, and capabilities of the device as well as the permissions of the app.</p><p>3. <strong>_CodeSignature/:</strong></p><p>A list that contains the code signature of the app, to guaranteeing the identity of the program.</p><p>4. <strong>Assets. car:</strong></p><p>A compressed file with all the graphical components included in the app (for example, icons, images).</p><p>5. <strong>Frameworks/:</strong></p><p>Includes dynamic libraries (dylib) and frameworks (framework) that the app uses.</p><p>6. <strong>PlugIns/:</strong></p><p>This directory may contain app extensions, packaged as . appex files. It is not necessarily in all IPA files.</p><p>7. <strong>Core Data:</strong></p><p>For storing other data and the data that synchronizes itself across the devices using iCloud.</p><p>8. <strong>PkgInfo:</strong></p><p>Offices another method to define the type and creator codes for the app.</p><p>9.<strong> Localization Files (e.g., en.lproj, fr.lproj, Base.lproj):</strong></p><p>These files contain the language modules and a default set of modules in the event a certain language is not recognized.</p><p><strong>Procedure of Performing Static Analysis on Mobile Applications using Mobile Security Framework (MobSF)</strong></p><p>MobSF is yet another tool that helps the user in performing static analysis on mobile applications. undefined</p><p><strong>Using MobSF</strong></p><p>Run the MobSF Web Interface:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JBSpfycr7Dg3yIPb" /></figure><p>1. Setting up MobSF starts the server and allows you to proceed to the next steps. Connect to the web interface by going online with the help of the browser.</p><p>2. Upload the IPA File:</p><p>3. Upload the IPA file into the MobSF and after loading, proceed with the static analysis.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZSbS72pCt4DRaWle" /></figure><p>4. <strong>Review the Analysis Results:</strong></p><p>Look for misconfigurations and vulnerabilities, such as:</p><ul><li>Insecure URL schemes</li><li>Improper permissions and App Transport Security (ATS) misconfigurations</li><li>Unsafe binary options</li><li>Hardcoded sensitive information (e.g., Firebase keys, email addresses)</li><li>Other potential security issues</li></ul><p>Some of the advantages of <strong>manual static analysis</strong> include increased accuracy, a detailed view of the application, and the ability to analyze a jailbroken iOS device.</p><p>That is why manual analysis of a static type helps to gain more detailed information regarding the app’s security. This process is possible only on an iOS device unlocked from its manufacturer restrictions.</p><p><strong>Obtaining the App Path</strong></p><p>1. SSH into the iOS Device:SSH into the iOS Device:</p><p>I would like to add the connection to the jailbroken device by SSH as the first step.</p><p>2. Locate the App:</p><p>Use the find command to locate the app’s plist files:Use the find command to locate the app’s plist files:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/622/0*9Kvy9bfFs9r7t_kZ" /></figure><p>3. Identify App Locations:</p><blockquote>System applications are located in <strong>/Applications</strong></blockquote><blockquote>User-installed apps are located in<strong> /private/var/containers/</strong></blockquote><blockquote>Bundled apps directory: <strong>/var/containers/Bundle/Application/</strong></blockquote><blockquote>Data directory: <strong>/var/mobile/Containers/Data/Application/</strong></blockquote><p><strong>Checking the Binary with otool</strong></p><p>1. Check for Position Independent Executable (PIE):</p><p>Ensures the app loads into a random memory address, enhancing security.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/550/0*JHQ5k4zKKWJZAXWN" /></figure><p>2. Verify Stack Canaries:</p><p>Protects against stack overflow attacks by validating stack integrity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/670/0*QEHjWbrq0qFguRLU" /></figure><p>3. Check for Automatic Reference Counting (ARC):</p><p>Prevents memory corruption by automatically managing memory</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/669/0*HXT2xi1cGOa8TU2w" /></figure><p>4. Ensure the Binary is Encrypted:</p><p>Confirms the binary is encrypted, protecting the app from tampering.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/813/0*oux8KZ0UsJmsrmVF" /></figure><p>5. Identify Sensitive/Insecure Functions:</p><ul><li>Weak Hashing Algorithms:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/0*5flpyinWbqnZx94t" /></figure><ul><li>Insecure Random Functions:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/668/0*4TrarSjthjMaGi5w" /></figure><ul><li>Insecure Memory Functions:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/694/0*cb7EQD3jbqiDWrnp" /></figure><ul><li>Vulnerable Functions:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/713/0*g3ynNyCeEc1PxIQZ" /></figure><p><strong>Some of the usual checks employed in the Info can be discussed and highlighted in the following manner: plist File</strong></p><p>The Info. plist file is a fundamental part of the application and the configuration of an iOS app, hence, configuring the plist settings properly and securely are crucial concerns for an app. Here are the common checks to perform:Here are the common checks to perform:</p><p><strong>1. Bundle Identifier</strong></p><p>Purpose:</p><p>The Bundle Identifier is a string that helps to define the specific App within the iOS operating system. It is employed with the operating system and the App Store to separate your app from competitors.</p><p>Why It Matters:</p><p>Uniqueness: Awards or IDs are given to a bundle to ensure that other applications will not conflict and this is important for app delivery and installation.</p><p>App Store Identification: It is used by the Apple App store to identify app versions and updates for the applications that are installed on the devices.</p><p>Entitlements and Permissions: Some of the entitlements and permissions for your app are provided based on the bundle identifier.</p><p>How to Check:</p><p>Make sure the bundle identifier adheres to reverse DNS naming convention (such as com.yourcompany.appname) and then makes sure it will not be the same as other apps.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/630/0*ieFQI5IpIGueuwXH" /></figure><p><strong>2. Bundle Version</strong></p><p>Purpose:</p><p>The scientific name for this is ‘CFBundleVersion’ and it refers to the build version of the app. It’s employed by the App Store and the system for following updates as well as organizing the installation of applications.</p><p>Why It Matters:</p><p>Update Management: It is very relevant because proper versioning ensures the App Store and the users to easily determine which updates are to be installed.</p><p>Bug Tracking: Knowing the versions can be pivotal for cost of failures, bugs, and other errors that may occur in between.</p><p>How to Check:</p><p>Make sure that the bundle version specified at each build includes the version number in numeric notation and is higher than in the previous version.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/462/0*9hjojENdaqtdF-wQ" /></figure><p><strong>3. Supported Device Types</strong></p><p>Purpose:</p><p>This key (UIDeviceFamily) specifies the types of devices on which the app can be installed and run, such as iPhone, iPad, or both.</p><p>Why It Matters:</p><p>Compatibility: Ensures that the app runs only on devices it is designed and tested for.</p><p>User Experience: Prevents users from installing the app on unsupported devices, which could lead to poor user experiences or crashes.</p><p>How to Check:</p><p>Ensure the supported device types are correctly specified.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/484/0*Namf0nxhSn1wb5Ay" /></figure><p><strong>4. Required Permissions</strong></p><p>Purpose:</p><p>This includes various keys that specify the permissions your app requires to access device features like the camera, microphone, location, etc.</p><p>Why It Matters:</p><p>User Privacy: Ensures the app requests only the permissions it needs, respecting user privacy.</p><p>App Store Compliance: Over-requesting permissions can lead to app rejection during the App Store review process.</p><p>How to Check:</p><p>Review and list only the necessary permissions in the Info.plist.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6K1neOL5KpiKax4q" /></figure><p><strong>5. URL Schemes</strong></p><p>Purpose:</p><p>URL Schemes are found under CFBundleURLTypes — these enable other applications or specific web browsers to open your application with the use of certain URLs.</p><p>Why It Matters:</p><p>Deep Linking: Helps with implementing link deep into your app, the user-experience factor.</p><p>Security: Using URL schemes not properly configured then another person may hijack a URL or get unauthorized access.</p><p>How to Check:</p><p>Specifically check that URL schemes are unique and use secure identifiers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/758/0*vBluTSnc0Pzpf4wM" /></figure><p><strong>6. NSAppTransportSecurity</strong></p><p>Purpose:</p><p>The NSAppTransportSecurity key defines the network security requirements for your app, such as enforcing HTTPS connections.</p><p>Why It Matters:</p><p>Data Security: Ensures that data transmitted over the network is encrypted, protecting against eavesdropping and man-in-the-middle attacks.</p><p>App Store Compliance: The App Store requires apps to use secure connections, and improper configurations can lead to rejection.</p><p>How to Check:</p><p>Ensure that your app’s transport security settings are correctly configured.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/984/0*wZALIXkMMQsNvdCL" /></figure><p><strong>Conclusion</strong></p><p>Making sure an iOS app is secure and error-free through static analysis is a multi-step process that involves using tools like MobSF, checking things manually on jailbroken devices, and thoroughly validating configuration files like Info.plist. By following these guidelines and doing these checks, developers can reduce security risks, meet App Store requirements, and provide users with a safer and more reliable experience. It’s important to regularly review and update these practices to keep up with changing security standards and threats.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cb09bd8f2927" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/static-testing-of-ios-applications-cb09bd8f2927">Static Testing of iOS Applications</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>