<?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 Aerialist71 on Medium]]></title>
        <description><![CDATA[Stories by Aerialist71 on Medium]]></description>
        <link>https://medium.com/@vishvesh71?source=rss-9f671edbd8cd------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*hTPMz9d4G6pMrAJ1</url>
            <title>Stories by Aerialist71 on Medium</title>
            <link>https://medium.com/@vishvesh71?source=rss-9f671edbd8cd------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 23:15:49 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@vishvesh71/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[Third-Party Risk Management Framework]]></title>
            <link>https://vishvesh71.medium.com/third-party-risk-management-framework-f39fa07394e8?source=rss-9f671edbd8cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/f39fa07394e8</guid>
            <category><![CDATA[tprm]]></category>
            <category><![CDATA[vendor-risk-management]]></category>
            <category><![CDATA[cyber-risk-management]]></category>
            <dc:creator><![CDATA[Aerialist71]]></dc:creator>
            <pubDate>Sat, 31 Oct 2026 15:16:00 GMT</pubDate>
            <atom:updated>2026-10-31T15:16:00.950Z</atom:updated>
            <content:encoded><![CDATA[<h3>I Built a Third-Party Risk Management Framework with 65 Security Controls and Automated Reporting Using Python</h3><p>Every organization uses third-party applications, SaaS platforms, cloud services, APIs, and external technology providers.</p><p>These tools help businesses move faster, improve productivity, and reduce operational overhead. However, every new vendor also introduces potential security, privacy, compliance, and operational risks.</p><p>A SaaS application might have weak authentication controls. A vendor might lack a reliable incident response process. Sensitive information might be stored in an unapproved geographical region. An application might not support enterprise SSO, or its contractual terms might not adequately address security incidents.</p><p>The challenge is not simply identifying these risks. It is assessing them consistently, collecting the right evidence, documenting the findings, assigning ownership, and ensuring that the appropriate stakeholders make an informed onboarding decision.</p><p>This is where Third-Party Risk Management (TPRM) becomes important.</p><p>I wanted to explore how much of this assessment and reporting process could be standardized and automated. As a result, I developed a TPRM framework consisting of a 65-control SaaS onboarding checklist and a Python-based reporting utility that converts assessment data from Excel into a structured Word report.</p><p>In this article, I’ll explain the problem I wanted to solve, how I designed the checklist, how the reporting workflow operates, and what I learned while building the project.</p><p>Github Repo Link : <a href="https://github.com/vishvesh1795/TPRM---Checklist-and-Tool">https://github.com/vishvesh1795/TPRM---Checklist-and-Tool</a></p><h3>1. Understanding the TPRM Problem</h3><p>Third-Party Risk Management is the process of identifying, assessing, monitoring, and managing the risks associated with external vendors and service providers throughout their relationship with an organization.</p><p>When an organization plans to onboard a new SaaS platform, the assessment should go beyond asking whether the vendor has an ISO 27001 certificate or a SOC 2 report.</p><p>Those documents can provide useful assurance, but they do not automatically establish that every security control relevant to a particular service is effective.</p><p>Consider a simple example.</p><p>An organization wants to onboard a cloud-based application that will process sensitive business information and integrate with internal systems.</p><p>Before approving the application, the organization needs to understand:</p><ul><li>What information will the application process and store?</li><li>Where will the information reside?</li><li>Does the vendor enforce appropriate authentication and authorization?</li><li>Is customer data isolated between tenants?</li><li>How are API keys, passwords, and other secrets protected?</li><li>Does the vendor have a documented vulnerability management process?</li><li>Are security incidents reported within contractually agreed timelines?</li><li>Are data processing and confidentiality obligations appropriately documented?</li><li>Can the organization obtain evidence supporting the vendor’s security claims?</li><li>What happens to the organization’s data when the contract ends?</li></ul><p>These questions involve multiple stakeholders, including Information Security, Application Security, Cloud Security, Procurement, Legal, Privacy, Compliance, Business Continuity, and Enterprise Risk Management.</p><p>Without a structured process, assessments can become inconsistent, evidence can be difficult to track, and important decisions can depend too heavily on individual reviewers.</p><p>I wanted to build a practical framework that would help organize these activities.</p><h3>2. Building a Control TPRM Checklist</h3><p>The first component of my project is an Excel-based checklist designed for SaaS applications, cloud services, enterprise software, and vendor onboarding.</p><p>Rather than creating a long questionnaire containing hundreds of generic questions, I focused on a set of 65 priority controls that could serve as a practical starting point for vendor assessments.</p><p>The checklist contains the original 50 priority controls and 15 additional medium- and low-severity controls.</p><p>The objective is not to replace every enterprise TPRM questionnaire. It is to provide a structured baseline that organizations can tailor according to their risk appetite, industry, regulatory obligations, data sensitivity, and technical architecture.</p><h3>What does the checklist cover?</h3><p><strong>1. Security assurance and application security</strong></p><p>This area examines technical controls that help protect the application and its data.</p><p>Examples include:</p><ul><li>Tenant isolation and authorization.</li><li>Encryption in transit and at rest.</li><li>Secrets management.</li><li>Authentication and privileged access.</li><li>Secure application configuration.</li><li>API security.</li><li>Vulnerability management.</li><li>Independent security testing.</li><li>Logging and monitoring.</li><li>Software supply chain security.</li></ul><p><strong>2. Identity and access management</strong></p><p>Identity controls are particularly important when a third-party application integrates with an organization’s identity provider or internal systems.</p><p>The assessment considers authentication, authorization, access provisioning, deprovisioning, session security, and the permissions granted to connected applications.</p><p><strong>3. Privacy and data protection</strong></p><p>Security assessments should establish how data is collected, processed, stored, retained, transferred, and deleted.</p><p>The checklist includes controls addressing data processing agreements, data minimization, retention, deletion, cross-border transfers, privacy requirements, and subprocessor management.</p><p><strong>4. Contractual and legal controls</strong></p><p>Technical security measures are only one part of vendor risk.</p><p>Contracts should appropriately address security responsibilities, confidentiality, incident notification, data return and deletion, audit rights, and other obligations relevant to the service.</p><p><strong>5. Compliance and regulatory requirements</strong></p><p>Organizations may have sector-specific or jurisdiction-specific obligations when onboarding third-party services.</p><p>The checklist includes considerations relevant to frameworks and requirements such as ISO 27001, NIST, India’s Digital Personal Data Protection framework, and applicable RBI outsourcing requirements.</p><p>However, applicability must be determined for the specific organization, service, data, and jurisdiction. The presence of a control in the checklist does not automatically mean that a particular regulation applies.</p><p><strong>6. Governance, business continuity, and vendor lifecycle</strong></p><p>The assessment also considers business ownership, service criticality, independent assurance, business continuity, disaster recovery, changes to the service, and vendor offboarding.</p><p>This broader approach is important because a vendor can introduce risk even when its application has no obvious technical vulnerability.</p><p>For example, a service without an effective recovery process might create significant business disruption even if its access controls and encryption are implemented correctly.</p><h3>Making the checklist actionable</h3><p>I wanted the checklist to be useful during an actual assessment, rather than functioning as a static list of questions.</p><p>For this reason, the Excel workbook includes fields for:</p><ul><li>Unique control identifiers.</li><li>Risk domains and control areas.</li><li>OWASP categories and CWE references, where applicable.</li><li>Inherent severity.</li><li>Assessment questions.</li><li>Vulnerability descriptions.</li><li>Business impact.</li><li>Test procedures and proof-of-concept guidance.</li><li>Evidence to request from the vendor.</li><li>Pass criteria and acceptance conditions.</li><li>Recommended remediation.</li><li>Potential compensating controls.</li><li>Control ownership.</li><li>Assessment status.</li><li>Residual severity.</li><li>Evidence and ticket references.</li><li>Remediation ownership and target dates.</li><li>Risk acceptance approval.</li><li>Retest results.</li><li>References and citations.</li></ul><p>This structure helps connect a control requirement to its assessment procedure, supporting evidence, identified gap, remediation action, and eventual closure.</p><p>It also encourages a distinction between inherent risk and residual risk.</p><p>Inherent risk represents the exposure before considering the effectiveness of relevant controls. Residual risk represents the exposure remaining after controls have been evaluated and applicable mitigations have been considered.</p><p>Importantly, residual risk should not be reduced merely because a vendor claims that a control exists. The assessment should be supported by appropriate evidence.</p><h3>3. Moving Beyond a Questionaire: Evidence-Based Assessment</h3><p>One of the most important principles behind this project is that a questionnaire response should not automatically be treated as proof that a security control is effective.</p><p>For example, a vendor might answer that all application traffic is encrypted.</p><p>A meaningful assessment would go further and request evidence appropriate to the service, such as:</p><ul><li>Supported TLS versions and cipher configurations.</li><li>Certificate management procedures.</li><li>Relevant architecture and data-flow diagrams.</li><li>Evidence covering internal service-to-service communication.</li><li>Results from appropriate technical testing.</li></ul><p>Similarly, an affirmative response to a question about vulnerability management should be supported by evidence of the vendor’s process, remediation timelines, scanning coverage, and closure verification.</p><p>The objective is to distinguish between a control that is documented, a control that is implemented, and a control whose effectiveness has been sufficiently demonstrated.</p><p>The level of validation should depend on the risk and the available evidence. Not every control can be validated through penetration testing; contractual controls, for example, require examination of the relevant agreements and approvals.</p><p>This distinction is essential for making TPRM assessments more meaningful.</p><h3>4. Automating the TPRM Report Using Python</h3><p>Creating the checklist was only the first part of the project.</p><p>The next challenge was report generation.</p><p>A typical assessment can require a structured report containing an executive summary, application details, assessment coverage, risk distribution, individual findings, business impacts, recommendations, and supporting evidence.</p><p>Preparing these reports manually can involve considerable repetitive work.</p><p>For my project, I developed a Python utility that takes the assessment workbook as input and generates a Word report using a predefined report template.</p><p>The intended workflow is straightforward:</p><p><strong>Step 1: Complete the assessment</strong></p><p>The assessor records the vendor and application information, evaluates the relevant controls, updates their status, and records supporting evidence. Mark the controls as pass. fail, not applicable etc and save the excel</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hvheSf7UW9NMiadAw6XTEA.png" /></figure><p><strong>Step 2: Provide the Excel workbook</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uo7Lb3-Uk2gE-BlvRsKOjA.png" /><figcaption>Extract the TRPM tool</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iEc0dMDTsIrXM1zdXmYwBw.png" /><figcaption>Install the requirements</figcaption></figure><p><strong>Step 3: Provide the Excel workbook</strong></p><p>The user selects or drags and drops the completed assessment file into the reporting utility or you can open the UI with the following command</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*efX0SV7QaWrHaEqILxlB8w.png" /><figcaption>Run the above command to open the UI of the tool</figcaption></figure><p><strong>Step 4: Process the assessment data</strong></p><p>The script reads the relevant fields, identifies the assessment results, and organizes the information for the report.</p><p><strong>Step 5: Generate the report</strong></p><p>The utility populates the Word template with application details, risk summaries, categorized findings, recommendations, and relevant assessment information.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XoB8phH8_oLGhu0TZ8o0Tg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9exLo6EfeJIP6f7crBUqmQ.png" /></figure><p><strong>Step 6: Review the output</strong></p><p>The generated document is reviewed to confirm that the results, evidence, risk ratings, and recommendations accurately reflect the underlying assessment without missing any controls.</p><p>The goal is to reduce repetitive document preparation while keeping the assessment itself evidence-driven and subject to human review.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*si9k6p0p3-Q4Wd3PqLU2Lw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QM0ACJ41hDDwE9BFtvfysQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FoVVxghwZf5kwU1uhwf4-Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vZnxXPdp0YuZnIB71p0_2w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4ngGTMUepLe-Yc5TPWzv7w.png" /></figure><h3>What does the generated report contain?</h3><p>The Word report is designed to provide a structured view of the assessment.</p><p>Its sections include:</p><ul><li>Assessment scope and application information.</li><li>Assessment methodology and limitations.</li><li>Risk classification.</li><li>Executive summary.</li><li>Graphical representation of findings.</li><li>OWASP categorization.</li><li>Risk summary and finding references.</li><li>Detailed vulnerability descriptions.</li><li>Business implications.</li><li>Recommended countermeasures.</li><li>Proof-of-concept guidance.</li><li>Evidence requirements.</li><li>Control ownership.</li><li>Report limitations and methodology annexures.</li></ul><p>The detailed finding format is particularly useful because it connects an identified control gap with its risk classification, relevant technical or governance context, potential consequences, recommended mitigation, and evidence requirements.</p><p>The report can therefore serve as a structured record for discussions between security teams, application owners, Procurement, Legal, Compliance, and business stakeholders.</p><h3>5. Turning Assessment Results Into Business Decisions</h3><p>A TPRM assessment should ultimately help an organization make a decision.</p><p>Identifying a control gap is not enough. The organization must understand its significance, decide whether remediation is necessary before onboarding, and establish who is accountable for the remaining risk.</p><p>For example, consider a vendor application that lacks enterprise SSO and has incomplete privileged-access controls.</p><p>The appropriate response depends on the organization’s requirements, the vendor’s implementation, the application architecture, the available compensating controls, and the consequences of unauthorized access.</p><p>The assessment should document:</p><ol><li>The control deficiency.</li><li>The evidence supporting the finding.</li><li>The inherent severity and relevant business context.</li><li>The required remediation.</li><li>Any proposed compensating controls.</li><li>The residual risk after validation.</li><li>The accountable risk owner.</li><li>The decision and approval required before onboarding.</li></ol><p>Some deficiencies may be remediated before go-live. Others may require a formally approved, time-bound exception if policy permits. Mandatory legal, regulatory, or contractual obligations cannot simply be waived through ordinary risk acceptance.</p><p>For this project, I included a recommended go-live approach: unresolved Critical findings should prevent approval, while High findings should be remediated or formally accepted in accordance with the organization’s policy.</p><p>The final decision should always follow the organization’s actual risk appetite, approval authority, and mandatory requirements.</p><p>This is where TPRM becomes more than a security checklist. It becomes a mechanism for supporting informed business decisions.</p><h3>Conclusion</h3><p>Third-party risk management is an important part of modern cybersecurity because organizations depend on external services to process information, integrate with internal systems, and support critical business activities.</p><p>A structured assessment helps organizations understand these dependencies, evaluate the vendor’s controls, identify weaknesses, and make more informed onboarding decisions.</p><p>My project combines a 65-control SaaS onboarding checklist with a Python-based Excel-to-Word reporting workflow to make this process more structured and repeatable.</p><p>It is a working foundation that can be refined through stronger evidence validation, risk-based control applicability, automated quality checks, and integration with enterprise risk management workflows.</p><p>I would be interested in hearing how other cybersecurity professionals approach TPRM assessments.</p><p><strong>How does your organization assess SaaS vendors before onboarding? Do you use custom checklists, standardized questionnaires, dedicated TPRM platforms, or a combination of these approaches?</strong></p><p>I’d welcome feedback, suggestions, and ideas for improving this framework.</p><p><em>Disclaimer: This project is a practical assessment aid and reporting utility. It is not a legal opinion, a certification, or a guarantee that a vendor is secure. Control applicability, risk acceptance, and onboarding decisions should be determined by the organization’s approved processes and qualified stakeholders.</em></p><h3>References and Further Reading</h3><ol><li>NIST, <a href="https://csrc.nist.gov/pubs/sp/800/161/r1/upd1/final">Cybersecurity Supply Chain Risk Management Practices for Systems and Organizations — SP 800–161 Rev. 1</a>.</li><li>NIST, <a href="https://csrc.nist.gov/pubs/sp/1326/final">Cybersecurity Supply Chain Risk Management: Due Diligence Assessment Quick-Start Guide — SP 1326</a>.</li><li>Shared Assessments, <a href="https://sharedassessments.org/sig/">Standardized Information Gathering (SIG) Questionnaire</a>.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f39fa07394e8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android Pentesting Part 3]]></title>
            <link>https://vishvesh71.medium.com/android-pentesting-part-3-a22bc7e28e21?source=rss-9f671edbd8cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/a22bc7e28e21</guid>
            <category><![CDATA[dynamic-analysis]]></category>
            <category><![CDATA[android-security]]></category>
            <category><![CDATA[android-pentesting]]></category>
            <category><![CDATA[mobsf]]></category>
            <dc:creator><![CDATA[Aerialist71]]></dc:creator>
            <pubDate>Tue, 20 Oct 2026 13:57:39 GMT</pubDate>
            <atom:updated>2026-10-20T13:57:39.537Z</atom:updated>
            <content:encoded><![CDATA[<p>Dynamic Findings:</p><p>Android dynamic analysis involves testing an application while it is running to identify security vulnerabilities that may not be apparent through static analysis alone.</p><p>Unlike static analysis, which focuses on reviewing source code and configuration files, dynamic analysis allows testers to observe the application’s runtime behavior, network communications, authentication mechanisms, and interactions with the underlying operating system.</p><p>Tools such as Burp Suite, Frida, and Objection help security testers intercept network traffic, inspect application behavior, and assess security controls under different runtime conditions. During this phase, testers should focus on insecure network communication, improper session management, authentication and authorization flaws, sensitive data exposure, SSL/TLS certificate validation, and runtime security mechanisms.</p><p>Each finding should be validated with a practical proof of concept (PoC), supported by appropriate evidence, and mapped to the relevant OWASP Mobile Application Security Testing Guide (MASTG) recommendations.</p><p>The ultimate goal is to understand how the application behaves in real-world scenarios, determine the actual impact of identified vulnerabilities, and recommend effective remediation measures. So lets get started with the impact</p><h3>DA-01 SSL Pinning Not Implemented</h3><p>The application does not implement certificate or public-key pinning. Once a trusted proxy certificate is installed on a test device, traffic between the app and its backend can be intercepted and inspected using a proxy tool such as Burp Suite.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/999/1*nOEwDB9z0816tonta8_d9w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*2WmQYyGrvpNnRQGbsRqZdA.png" /><figcaption><em>Application traffic intercepted via proxy, confirming the absence of SSL pinning</em></figcaption></figure><h3>DA-02 No Anti-Debugging Mechanism Implemented</h3><p>The application does not detect or block an attached debugger. A tester was able to attach jdb / Frida to the running process and step through, hook, or modify its runtime behaviour.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/990/1*FPmJRF7_h83Xivfqjx7Ccg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*4xrCa7ExBAulLD-9AbdSVQ.png" /><figcaption><em>The application accepts a debugger attachment without any detection or restriction.</em></figcaption></figure><h3>DA-03 Missing Useful HTTP Security Headers</h3><p>Server responses returned to the app’s API calls omit several recommended security headers, including Strict-Transport-Security, X-Content-Type-Options, and Cache-Control directives on responses that carry sensitive data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/988/1*YO_QOXg5OQbdRVy38WbDww.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*JXDfgeF1o0rNlsh_yPwakA.png" /><figcaption><em>API response headers captured during testing, showing the missing security headers.</em></figcaption></figure><h3>DA-04 Adversary Can Fingerprint the Application Server From HTTP Responses</h3><p>Server response headers disclose backend software and version information — including web server and application framework version banners — that were captured during testing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/987/1*gX52DzYUkWKKI9gQ4QGizg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*a8VfCdFIT5ETdZbPs-5vtQ.png" /><figcaption><em>Server version information disclosed in the HTTP response headers.</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*jR6Sqy1MZri__pAKDfaNOA.png" /><figcaption><em>Application framework version disclosed in a separate response.</em></figcaption></figure><h3>DA-05 Password Replay Attack</h3><p>A previously captured authentication request — including the credentials or tokens it contains — can be resent to the server and is accepted again, indicating the backend has no protection against request replay.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/992/1*KByJbDcwdBLMnzGOlynQAQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*re-n68db4wLsfIQiv3FZXQ.png" /><figcaption><em>An authentication request captured during testing</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*mye9UDq0CeKF17HLZ5awtQ.png" /><figcaption><em>The same captured request successfully replayed against the server.</em></figcaption></figure><h3>DA- 06 TLS Padding Oracle Information Disclosure Vulnerability (TLS POODLE)</h3><p>Closely related to the SSLv3 finding above, the server’s TLS configuration includes CBC-mode cipher suites that remain susceptible to padding-oracle attacks capable of leaking encrypted content byte-by-byte.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/992/1*PZUpi9qMFIyx-zioevKH4A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*0EMLWWvU2HmjYKjRcK4UbQ.png" /><figcaption><em>TLS configuration scan confirming the padding-oracle weakness</em></figcaption></figure><h3>DA-07 Session Cookie Attributes Are Not Set Properly</h3><p>Session cookies issued by the backend are missing recommended security attributes — specifically Secure, HttpOnly, and/or SameSite.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/996/1*iOGOBa0cGjav9NoCfPECKA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*aL_BHt5N0ZivrjWdqw6jaw.png" /><figcaption><em>Session cookie captured during testing, showing the missing security attributes.</em></figcaption></figure><h3>DA-08 Adversary Can Access the Default Web Page</h3><p>An embedded web endpoint reachable by the application exposes a default or placeholder web page directly, rather than the app-controlled content that end users are expected to see.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/995/1*w3DiUmn8uCzHDJB749KXow.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*ndyPBz0b3WeUw3Zwnott-A.png" /><figcaption><em>The default web page reachable directly through the application’s embedded browser component.</em></figcaption></figure><h3>DA-09 Mobile App URL Accessed Through a Web Browser</h3><p>Backend endpoints intended to be consumed only by the mobile application were found to be directly reachable from a standard desktop web browser, without any app-specific validation preventing access.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/990/1*QuLt0A5mxhsDLyUsKPv_BA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*RlU7YK2ICO7PetdYX1AfFA.png" /><figcaption><em>A mobile-app-only URL loaded and rendered successfully in a desktop web browser.</em></figcaption></figure><h3>DA-10 Adversary Can Perform Malicious Activity via Parameter Manipulation</h3><p>Request parameters — including object identifiers, role flags, and monetary amounts — can be altered using an intercepting proxy, and the server processes the modified values without adequate authorisation checks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/995/1*jsc7fPLy27s1q4QUIPvj3w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*8u7RILkh82bqpaen5fy-jA.png" /><figcaption><em>Original request parameters captured prior to manipulation.</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*FBAJb1UUjfMNNvKWDSi6TQ.png" /><figcaption><em>Parameters modified using an intercepting proxy</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*fqMYuKOUZdhCcTtaA4cYJQ.png" /><figcaption><em>The server processes the manipulated request without additional authorisation checks.</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*tc0UmBQBW_SXzvrHQF51sw.png" /><figcaption><em>Resulting unauthorized outcome from the manipulated request</em></figcaption></figure><p><strong>Chapter Summary &amp; Key Takeaways</strong></p><p>Dynamic analysis provides valuable insights into an Android application’s security posture by examining its behavior during execution. Throughout this chapter, we explored how to intercept and analyze application traffic using Burp Suite, investigate runtime behavior, and identify vulnerabilities through practical testing techniques.</p><h3>Key Takeaways</h3><ul><li><strong>Network Traffic Analysis:</strong> Inspect HTTP/HTTPS communications to identify sensitive data exposure, insecure transmission, and improper certificate validation.</li><li><strong>Authentication &amp; Session Management:</strong> Evaluate login mechanisms, session handling, token security, and logout functionality.</li><li><strong>Data Exposure:</strong> Examine application behavior for sensitive information leakage through network traffic, logs, runtime storage, and application responses.</li><li><strong>Runtime Security Testing:</strong> Analyze application behavior using tools such as Frida and Objection to assess the effectiveness of security controls.</li><li><strong>Vulnerability Validation:</strong> Develop practical PoCs, collect supporting evidence, assess business impact, and distinguish genuine vulnerabilities from false positives.</li><li><strong>Remediation &amp; Reporting:</strong> Document each confirmed finding with its severity, technical details, impact, reproduction steps, and recommended mitigation.</li></ul><p><strong>Remember:</strong> Dynamic analysis complements static analysis; neither approach is sufficient on its own to establish an application’s overall security posture. Combining both approaches provides broader coverage and helps testers identify vulnerabilities that might otherwise go undetected.</p><p>In this new age era there are also other super critical and high findings that one should read like intent injection, content provider bypass using drozer, task hijacking, calling internal activity without authentication.</p><p>So, keep learning, exploring, and sharpening your skills! If you have any suggestions for improving this article or would like me to cover other Android application security concepts in more detail, feel free to share your thoughts in the comments. Your feedback and suggestions are always welcome!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a22bc7e28e21" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android Pentesting Part 2]]></title>
            <link>https://vishvesh71.medium.com/android-pentesting-part-2-46af22a74819?source=rss-9f671edbd8cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/46af22a74819</guid>
            <category><![CDATA[mobsf]]></category>
            <category><![CDATA[static-analysis]]></category>
            <category><![CDATA[android-pentesting]]></category>
            <category><![CDATA[reduce-false-positives]]></category>
            <dc:creator><![CDATA[Aerialist71]]></dc:creator>
            <pubDate>Tue, 20 Oct 2026 13:56:22 GMT</pubDate>
            <atom:updated>2026-10-20T13:56:22.151Z</atom:updated>
            <content:encoded><![CDATA[<p>Static Analysis Findings:</p><p>With the AndroidManifest.xml, apktool.yml, and decompiled JAR available for review, the following findings were identified during static analysis. So lets jump into the main section of identifying the vulnerabilities.</p><p>GitHub Link :<a href="https://github.com/vishvesh1795/Android-Pentesting-Static-Checklist">https://github.com/vishvesh1795/Android-Pentesting-Static-Checklist</a></p><h3>SA-01 Application Runs on an Older, Vulnerable Android Platform</h3><p>The application declares a minimum supported SDK level that allows it to be installed on Android OS versions with publicly known, unpatched vulnerabilities. An attacker who gains access to a device running one of these outdated OS versions can chain a known platform-level flaw with the application to compromise the device or extract sensitive information — without needing to find a bug in the app itself.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*d_SRqNqJv4KCYLHZLL-V7w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/978/1*cGBhmcp68F0KSKUIPcbeaA.png" /><figcaption><em>The application installs successfully on an outdated, unpatched Android platform version.</em></figcaption></figure><h3>SA-02 No Source Code Obfuscation Implemented</h3><p>Decompiling the APK produces Java source code that closely mirrors the original — class names, method names, and variable names are all intact and readable. This makes it straightforward for an attacker to understand business logic, locate security controls, and pinpoint high-value targets for further attack.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/984/1*gIdiDfro8TjWyAXEDDiC-Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*B-J6EE3gfbe_ge4St0MHfA.png" /><figcaption><em>Class and method names remain fully readable after decomplications, confirming the absence of obfuscation</em></figcaption></figure><h3>SA-03 Application Has Set Insecure Permissions</h3><p>Reviewing the AndroidManifest.xml showed that the application requests or sets several insecure configuration values that widen its attack surface, including access to the device’s shared storage, the ability to track network connectivity state, and settings that expose the application to easier tampering.</p><p>The specific insecure settings identified were:</p><p>● WRITE_EXTERNAL_STORAGE — broad write access to shared/external storage that other apps can also read.</p><p>● android:allowBackup=”true” — application data can be extracted from the device using adb backup, even without root.</p><p>● android:debuggable — a debugger can be attached to the application in a production build.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/992/1*DcJtlKsFzrobwnaQPxYTDg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*e9HO0Tj1_zCaY4Dm01rsZg.png" /><figcaption><em>AndroidManifest.xml showing the insecure permission and configuration flags identified during static review.</em></figcaption></figure><h3>SA-04 printStackTrace() Used in Application Source Code</h3><p>The application calls printStackTrace() and similar verbose logging in several places. When an exception surfaces a full stack trace to logs (or, worse, to the user or an intercepted response), it hands the attacker information that makes further attack meaningfully easier — for example, a malformed SQL query string, the type of database in use, or the version of an underlying framework or library. This kind of detail lets an attacker target known vulnerabilities in those specific components.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*9Lgrn95Jg5mtt_0rL1kRaw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*KZQ8lxaTYUUhnJ7ENR85qA.png" /><figcaption><em>printStackTrace() calls identified in the decompiled source code.</em></figcaption></figure><h3>SA-05 Application Uses addJavascriptInterface()</h3><p>The application exposes a native Java object to JavaScript running inside a WebView via addJavascriptInterface(). If that WebView ever renders content that isn’t fully trusted — a compromised third-party script, an open redirect, or any attacker-influenced page — the untrusted JavaScript can call the exposed Java methods directly, potentially reaching functionality or data that was never meant to be reachable from a web page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/987/1*77L0PYzseIuVJz5-Qpkg0Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*Lq_1YVnHqlAzWOXMY7JRiA.png" /><figcaption><em>addJavascriptInterface() usage identified in the decompiled source code</em></figcaption></figure><h3>SA-06 WebView Configured With JavaScript Enabled</h3><p>WebView is the component Android apps use to render web content inline, using the WebKit rendering engine to display pages, navigate history, and run scripts. Because a WebView can render HTML and JavaScript supplied from outside the app, enabling it via setJavaScriptEnabled(true) reintroduces familiar web security issues — most notably cross-site scripting — into a native mobile context if the content it loads isn’t fully trusted.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/987/1*JLBGJy1YYSYr1HmmYShPFA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*14ifW0OGaf2DEFqtmRRZGA.png" /><figcaption><em>WebView initialisation code with JavaScript enabled.</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*j9JjAQZLUrDJUqklOxYu0A.png" /><figcaption><em>Additional WebView configuration identified during source review</em></figcaption></figure><h3>SA-07 Sensitive Information Visible in Application Source Code</h3><p>An AES encryption key was found hardcoded inside the APK. Because the key ships inside the application package itself, anyone who decompiles the app can recover it and use it to decrypt protected data, or to forge validly-encrypted payloads — defeating the encryption control entirely rather than merely weakening it.</p><p>Note: hardcoded sensitive information is not limited to cryptographic keys — the same risk applies equally to hardcoded credentials, embedded API secrets, or SQL query fragments left in the source or resources.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/997/1*_RSolGB6q8JCkZ2t74RprA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*9tvfgO-WZQ3-P__M4fm1dw.png" /><figcaption><em>Hardcoded AES key identified in the application source</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*2QX9ZMbz612thvTPdQY_ng.png" /><figcaption><em>The same hardcoded key confirmed in the Smali representation of the APK.</em></figcaption></figure><h3><strong>Chapter Summary &amp; Key Takeaways</strong></h3><p>Android static analysis is a crucial phase of application security testing that helps identify potential vulnerabilities by examining the application’s source code, configuration files, and embedded resources without executing the application.</p><p>Testers should focus on <strong>AndroidManifest.xml configurations, insecure data storage, hardcoded credentials and API keys, cryptographic weaknesses, improper permission handling, insecure WebView configurations, and exposed application components</strong>.</p><p>It is equally important to review network security configurations, certificate validation mechanisms, third-party libraries, and debugging settings for potential security weaknesses.</p><p>Tools such as JADX, Apktool, and MobSF can help automate vulnerability detection and simplify manual code review. However, automated findings should always be manually validated to eliminate false positives and assess their actual security impact.</p><p>Finally, map confirmed vulnerabilities to the relevant OWASP Mobile Application Security Verification Standard (MASVS) and Mobile Application Security Testing Guide (MASTG) categories, and document their impact, evidence, and recommended remediation.</p><p>In the next chapter, we will move on to <strong>dynamic analysis of the Android application</strong>, where we will identify and validate security vulnerabilities through practical testing, demonstrate proof of concepts (PoCs), and explore effective mitigation strategies for each finding.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=46af22a74819" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android Pentesting Part 1]]></title>
            <link>https://vishvesh71.medium.com/android-pentesting-part-1-ed585c18d499?source=rss-9f671edbd8cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/ed585c18d499</guid>
            <category><![CDATA[android-basic]]></category>
            <category><![CDATA[static-analysis]]></category>
            <category><![CDATA[mobile-owasp]]></category>
            <category><![CDATA[android-pentesting]]></category>
            <dc:creator><![CDATA[Aerialist71]]></dc:creator>
            <pubDate>Tue, 20 Oct 2026 13:54:55 GMT</pubDate>
            <atom:updated>2026-10-20T13:54:55.034Z</atom:updated>
            <content:encoded><![CDATA[<p>We will break down this article series into <strong>three comprehensive parts</strong>, covering the Android application security assessment process from the fundamentals to advanced testing techniques.</p><p><strong>Part 1: Understanding Android Architecture and Reverse Engineering</strong></p><p>We will explore the fundamentals of Android application architecture, understand how Android applications work, and learn how to decompile APK files to inspect and reverse engineer application code.</p><p><strong>Part 2: Static Analysis of Android Applications</strong></p><p>In this part, we will dive deep into static analysis using various security testing tools. We will explore common vulnerabilities, understand their corresponding OWASP categories, analyze security findings, and discuss practical mitigation techniques for each vulnerability in detail.</p><p>Don’t worry! I’ll also provide an extensive Android application security testing checklist covering key test cases, along with links to the tools required to perform these assessments.</p><p><strong>Part 3: Dynamic Analysis of Android Applications</strong></p><p>In the final part, we will focus on dynamic analysis, using tools such as Burp Suite to intercept and inspect application traffic, analyze runtime behavior, identify security vulnerabilities, and understand the findings associated with dynamic testing.</p><p><strong>Bonus Section: Advanced Android Security Testing Techniques</strong></p><p>We’ll also explore advanced techniques, including SSL pinning bypass, root detection bypass, and application instrumentation using Frida and Objection. We’ll examine how hooking and reverse engineering techniques can help security testers assess application defenses.</p><h3>The Goal Behind This Series</h3><p>The primary goal of this series is to create a <strong>practical, beginner-friendly reference guide for Android application security testing</strong>.</p><p>When I started exploring this domain, I faced challenges in understanding where to begin, which tools to use, and how to approach an assessment practically. Through this series, I want to help others overcome those same challenges by providing a structured learning path, practical examples, comprehensive checklists, and actionable remediation guidance.</p><p>My aim is to help aspiring security testers build the <strong>knowledge, practical skills, and confidence</strong> needed to conduct Android application security assessments effectively. So lets get started ……..</p><h3>Anatomy of an APK</h3><p>An APK (Android Package) is simply a ZIP archive with a specific internal structure, and that fact alone is a tester’s best friend — renaming a copy to .zip and extracting it (as shown in the Static Analysis chapter) gives immediate access to almost everything the app ships with.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*WbYLkztSWpZ4cT9D6feAAQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/924/1*2rztPtMpp89eXOIw_XzKSQ.png" /></figure><p>Owasp Top 10 Mobile : <a href="https://devguide.owasp.org/en/07-training-education/06-mobile-top-ten/">https://devguide.owasp.org/en/07-training-education/06-mobile-top-ten/</a></p><p><strong>Best Practice</strong></p><p>Treat this chapter as a checklist, not just background reading: before diving into a new target app, walk through each row above against the manifest and the decompiled source. Most of the findings catalogued in and 4 trace back to exactly one of these ten building blocks.</p><p><strong>STATIC ANALYSIS</strong></p><p>The tools used for static analysis in this handbook are apktool (or APK Easy Tool), dex2jar, and JD-GUI (or JADX) as an alternative. The walkthrough below decompiles and extracts the target APK then documents the vulnerabilities identified while reviewing the resulting source.</p><h3>Step 1 — Decompile the APK With apktool</h3><p>Decompile the target APK using apktool with the command apktool d apkname.apk. This unpacks the compiled resources and disassembles the app’s bytecode into a readable Smali representation, ready for manual review.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*zg5zrvVCX1H2XlUt_kyt3Q.png" /><figcaption><em>Running apktool to decompile the target APK from the command line.</em></figcaption></figure><p>Link to download : <a href="https://apktool.org/">https://apktool.org/</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/692/0*Esgd9yNMQSE836SG" /></figure><h3>Step 2 — Review the Decompiled Output Folder</h3><p>apktool creates a new folder named after the application. Opening it reveals a smali folder (the disassembled bytecode), the recovered AndroidManifest.xml, and an apktool.yml file — the three starting points for identifying vulnerabilities in later steps.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*KybCUQqQv3XKYnfcylORGg.png" /><figcaption><em>Decompiled output folder containing the smali directory, AndroidManifest &amp; apktool.yml.</em></figcaption></figure><h3>Step 3 — Rename the APK to .zip and Extract It</h3><p>Separately, change the extension of the same APK file from .apk to .zip and extract it. Because an APK is itself a ZIP archive, this gives direct access to its raw contents without going through apktool.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*cxcpxPT1GmGERCYg946XFA.png" /><figcaption><em>Renaming the APK file extension to .zip in preparation for extraction.</em></figcaption></figure><h3>Step 4 — Locate classes.dex</h3><p>Extracting the renamed archive creates a new folder containing the application’s classes.dex file — the compiled Dalvik bytecode that the Android Runtime executes on-device.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*snD_q6k6bvpkBIMUKeGgJw.png" /><figcaption><em>The extracted archive contents, including the classes.dex file.</em></figcaption></figure><h3>Step 5 — Convert classes.dex to a Readable JAR With dex2jar</h3><p>The DEX file is not directly human-readable, so convert it into a standard Java JAR using dex2jar with the command d2j-dex2jar.bat classes.dex. This produces an executable JAR file suitable for decompilation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*0i6E5mzA9LR3tZs-Ym0ztQ.png" /><figcaption><em>Running dex2jar to convert classes.dex into a Java-readable JAR file.</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*81H3wNWjkNilKjOUieZOsw.png" /></figure><h3>Step 6 — Open the JAR in JD-GUI (or JADX) and Review the Source</h3><p>Open the newly generated JAR file in JD-GUI or JADX to browse the recovered Java source. This is where the tester begins looking for sensitive information — hardcoded secrets, weak logic, or missing security controls — that feed directly into the findings documented in Part 2.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*tLxlJi7VdaRYH0KtsF8e1A.png" /><figcaption><em>The recovered JAR file opened in JD-GUI for source-level review.</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*B-J6EE3gfbe_ge4St0MHfA.png" /><figcaption><em>Fully readable class and method names, confirming the absence of code obfuscation.</em></figcaption></figure><p>Now that we have successfully decompiled the application, we have access to the files and source code required to begin identifying potential security vulnerabilities. In the next section, we will dive into <strong>static analysis</strong>, exploring how to examine these files, identify security weaknesses, and understand their potential impact.In the next article we will explore the static findings of the vulnerable android application.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed585c18d499" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SBOM vs CBOM vs HBOM]]></title>
            <link>https://vishvesh71.medium.com/sbom-vs-cbom-vs-hbom-5a0a580cb06b?source=rss-9f671edbd8cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/5a0a580cb06b</guid>
            <category><![CDATA[sbom]]></category>
            <category><![CDATA[cbom]]></category>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[sbom-generation]]></category>
            <category><![CDATA[hbom]]></category>
            <dc:creator><![CDATA[Aerialist71]]></dc:creator>
            <pubDate>Mon, 19 Oct 2026 13:16:09 GMT</pubDate>
            <atom:updated>2026-10-19T13:19:51.032Z</atom:updated>
            <content:encoded><![CDATA[<p>Many organizations are increasingly focusing on software supply chain security and the role of Bills of Materials (BOMs) in identifying and managing associated risks. However, not everyone is aware that there are different types of BOMs, each designed to address specific security and compliance requirements.</p><p>In this article, we’ll explore these different types in detail, breaking down complex concepts into simple, easy-to-understand language. We’ll cover what each BOM is, why it matters, how it is structured, the vulnerabilities it helps identify, and the mitigation strategies organizations can implement to strengthen their security posture.</p><p>Let’s get started!</p><p>The table below provides an overview of the different types of Bills of Materials, what each one represents, and the key questions it helps organizations answer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_9vwPfhIA9JumW3M_tbSqg.png" /><figcaption>Bill of Material Answers</figcaption></figure><p>A bill of materials is an inventory, not a security certificate. It helps people ask better questions and act faster; it does not, by itself, prove that a product is safe or vulnerable.</p><p><strong>1. Introduction</strong><br>A modern product is assembled from many parts. A web service may include an operating system, open-source libraries, application code and encryption software. A connected device may also include a circuit board, processor, memory chips, radio modules and firmware. To manage risk, teams need a reliable inventory of what is actually present.</p><p>A Bill of Materials (BOM) is that inventory. The three terms in this guide answer different questions: an<strong> SBOM describes software ingredients</strong>; a <strong>CBOM describes cryptographic ingredients</strong> and where they are used; and an<strong> HBOM describes physical hardware components</strong> and, depending on the purpose, their suppliers and provenance. CycloneDX supports a common data model spanning software, hardware and cryptographic assets, while SPDX is an international open standard widely used for software supply-chain information.</p><p>A useful mental model is three camera views of one product. They overlap, but none replaces the others. A device’s firmware may be software listed in an SBOM; the flash chip containing it belongs in an HBOM; and the signing algorithm or device certificate used by that firmware belongs in a CBOM.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/938/1*hqzyXDob3WdnyWt6Fj3Npw.png" /><figcaption>Figure 1. Three complementary views of one product. The boundaries overlap; use case determines exactly what is included.</figcaption></figure><p>An inventory can be partial, out of date, or uncertain. Good practice is to state what was scanned, when it was scanned, how it was built, and what the tool could not see. A scanner’s silence is not proof that a component or risk is absent.</p><p><strong>2. Structure of SBOM vs CBOM vs HBOM</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/1*OtbfTdsOemp40bNJeLjtsA.png" /><figcaption>Structure associated with BOM</figcaption></figure><p><strong>A. SBOM: the software ingredient list</strong></p><p>An SBOM is a structured, often machine-readable list of software components associated with a product. It can include the product’s name and version, the component name and version, supplier information, identifiers, relationships, and the tool or process that created the inventory. The word “nested” matters: an application can depend on a library that depends on other libraries. CISA describes an SBOM as an inventory of software components and notes that VEX can accompany it to say whether a product is actually affected by a reported vulnerability.</p><p>For example, a photo application might depend on an image library, which in turn depends on a compression library. The SBOM records the chain so teams can quickly find every product that includes a vulnerable version.</p><p><strong>B. CBOM: the cryptography inventory</strong></p><p>A CBOM is a map of cryptographic assets and how they relate to software or systems. It can describe algorithm families, cryptographic libraries, key and certificate material, and use relationships. The inventory should not expose secret private keys. In most cases, record safe metadata such as key type, size, location or reference, certificate fingerprint and owner — not the secret value itself. CycloneDX highlights its ability to represent algorithms, keys, certificates and relationships to software components.</p><p>Example: “The gateway’s TLS service uses OpenSSL; the service presents certificate fingerprint X; the certificate uses an elliptic-curve signature; an older RSA-based client connection remains enabled.” That is more useful for planning a cryptographic upgrade than simply knowing a crypto library is installed.</p><p><strong>C. HBOM: the physical-parts inventory</strong></p><p>An HBOM describes the hardware in a product or host. Depending on the use case, it may include the finished product, subassemblies, component names, part numbers, revisions, manufacturers, suppliers, quantities, locations and provenance. A router might contain a main board, a system-on-chip (SoC), memory, flash storage, a Wi-Fi module and sensors. CISA’s HBOM framework groups its fields around the BOM header, entities and locations, finished-good details, component descriptions and technical/production details. It also emphasizes that the fields selected should depend on the intended use.</p><p>HBOM scope varies in practice. An inventory collected from a live computer may discover host hardware, while a manufacturer’s engineering or procurement HBOM may go deeper into board-level parts, suppliers and manufacturing locations. Do not assume a host-scanner export is a complete manufacturing supply-chain record.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YramsQThG3T-QPO_--hcnA.png" /><figcaption>Example product map: the product-level view links software dependencies, crypto assets and physical parts.</figcaption></figure><p>In this example, the board contains a processor and memory; the processor boots firmware and an operating system; software components use a TLS implementation; and the TLS implementation uses algorithms and a device certificate. Each inventory contributes different evidence. Join them using stable product names, versions, identifiers and relationships where possible.</p><h3>3. Importance of the three inventories</h3><p>The practical benefit is faster impact analysis. When a newly disclosed flaw affects a library, an SBOM helps answer “Which products include it?” When a cryptographic algorithm is deprecated or a certificate expires, a CBOM helps answer “Where is it used, and what depends on it?” When a supplier or hardware component is recalled, restricted, counterfeit, or unavailable, an HBOM helps answer “Which products contain it, and what is the replacement path?”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1021/1*_wlmuSSuexPyEFhY9KUHHw.png" /></figure><p>Inventories also improve routine operations: asset ownership, patch planning, software licensing, lifecycle decisions, supplier resilience and audit readiness. They are useful only when they are refreshed as products change and when there is a response process behind the data. A static BOM quickly becomes a historical snapshot.</p><h3>4. Standards and tools</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/1*mgHrD5LwNACkJvPv0o1WkA.png" /></figure><p>A format is not a scanner. CycloneDX or SPDX defines how to express information; a separate tool discovers, validates, enriches or analyzes that information. One product can publish both SPDX and CycloneDX exports if consumers need different formats, but avoid silently losing fields when converting between them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bZz83NTNMBZigkuaZV5lIQ.png" /></figure><h3>5. How to perform SBOM vs CBOM vs HBOM using open-source tools</h3><p>Use a representative, trusted project or device. Pin the product version, preserve the output and note the tool version, date, scope and any permissions required. Treat all commands below as illustrative; consult the tool’s current installation instructions and run scans in a controlled environment.</p><h3>A. Create and scan an SBOM</h3><p>Syft can inventory a local project or container image and export CycloneDX or SPDX. For example:</p><p># Create a CycloneDX SBOM for a project directory<br><strong> syft ./my-project -o cyclonedx-json=./sbom.cdx.json</strong><br> <br> # Or inspect / export an image<br><strong> syft alpine:latest -o spdx-json=./image.spdx.json</strong></p><p>Then scan the generated SBOM with Grype, or scan it with Trivy. Grype supports SBOM input; Trivy documents both CycloneDX and SPDX input.</p><p><strong>grype sbom:./sbom.cdx.json</strong><br><strong> trivy sbom ./sbom.cdx.json</strong></p><p><strong>A beginner-friendly routine is</strong>: (1) build the exact release artifact, (2) generate the BOM from that artifact and its build evidence, (3) scan it, (4) check important findings against the upstream advisory and product context, (5) update or replace affected components, then (6) regenerate and rescan. For source-first scanning or guided fixes, OSV-Scanner can scan a repository recursively; review any automated change before merging.</p><h3>B. Create a CBOM</h3><p>For code-centric crypto discovery, cdxgen supports CBOM workflows, while CBOMkit provides source scanning, viewing and policy checks. Coverage differs by language and library. The CBOMkit project explicitly warns that scanning a repository without building it can reduce accuracy for some Java code; a build-aware pipeline can improve results.</p><p># cdxgen examples (check current CLI version and project-specific options)<br> <strong>cbom -t java -o cbom.json </strong><br> <br> # Include source-derived crypto for a JavaScript / TypeScript project<br><strong> cdxgen — include-crypto -o cbom.json /path/to/project</strong><br> <br> # Dynamic trace around a test command, where supported<br><strong> tracebom — cbom-output cbom-runtime.json — npm test</strong></p><p>Review the output with a human who understands the application. Confirm that the inventory names where an algorithm is used, whether it is actually active, the certificate/key reference and ownership, and whether the observed configuration matches the deployed system. Never put secret key bytes, passwords, tokens or private certificate material in a shared BOM. Use a safe reference or fingerprint instead.</p><p>For a CBOM, “vulnerability scanning” is not just matching package versions. The important questions include whether algorithms are allowed, whether key sizes and certificate validity are appropriate, whether a crypto library has a security flaw, and where a cryptographic dependency sits in the system. A CBOM makes those checks more targeted; it does not perform them automatically.</p><h3>C. Create an HBOM</h3><p>For a live host, cdxgen offers a hardware-specific `hbom` command. The current guide lists supported host collectors and command options; installed utilities, operating system, processor architecture and privileges affect the result. By default, some sensitive identifiers are redacted.</p><p># Generate a host hardware BOM<br><strong> hbom -o hbom.json<br></strong> <br> # Ask the tool to validate its output, if supported by installed version<br> <strong>hbom -o hbom.json — validate</strong><br> <br> # Collect a merged hardware + runtime host view (where supported)<br><strong> hbom — include-runtime -o host-view.json</strong><br> <br> # Inspect missing utilities / permission-sensitive collection<br> <strong>hbom diagnostics</strong></p><p>For a product-level HBOM, gather and reconcile engineering BOMs, procurement/ERP data and supplier disclosures. Normalize manufacturer names and part numbers; record revision and quantity; connect components to parent assemblies; and mark unknown, substituted or unverified information. Ask suppliers for updates when a part or manufacturing location changes. CISA’s framework explains that HBOM data requirements vary by use case and that component/supplier identity resolution can be difficult.</p><p>Protect serial numbers, MAC addresses, production locations and other sensitive supply-chain identifiers. Collect and distribute only the detail needed for the task, and restrict access where exposure could create privacy or security risk.</p><h3>6. Vulnerabilities associated with SBOM vs CBOM vs HBOM</h3><p>A BOM is primarily an inventory. Vulnerability tools compare that inventory with vulnerability information or policy. The risk categories differ by what each inventory can see:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*48H7QuWNuyj_GZhDDXgJVA.png" /></figure><p>Vulnerability databases and product naming are imperfect. An SBOM may list a package under a name that does not match an advisory. A CBOM may detect an algorithm in test code that is not present in production. An HBOM may use a rebranded part number or omit deeper subcomponents. Findings therefore need evidence and context before they become incident claims.</p><p>For software, tools such as Grype, Trivy and OSV-Scanner connect package identities to known advisories. For crypto, findings may come from algorithm-policy checks, certificate analysis, code review or vendor advisories. For hardware, teams often need manufacturer security notices, firmware bulletins and supplier data in addition to common vulnerability identifiers. Dependency-Track supports portfolio monitoring and multiple intelligence sources.</p><p>A scanner reporting “no findings” does not certify safety. It may mean the database has no matching advisory, the version could not be identified, a collector missed a component, the issue is not represented in that tool, or the inventory is incomplete. Always review scan coverage and data freshness.</p><h3>7. Mitigation in SBOM vs CBOM vs HBOM</h3><h3>Mitigate software risks — SBOM</h3><p>Start by checking whether the affected component and exact version are present in the deployed build. Confirm the advisory and fixed version. Upgrade or replace the component, rebuild the product, test compatibility, and regenerate the SBOM. If the code is not affected, or is not reachable in the product, document the evidence and communicate status using a VEX process where appropriate. Do not suppress a finding solely because it is inconvenient.</p><h3>Mitigate cryptographic risks — CBOM</h3><p>Prioritize exposed or prohibited algorithms, weak parameters, expired certificates and crypto libraries with relevant security fixes. Replace weak or obsolete mechanisms with approved alternatives; rotate or reissue keys/certificates when indicated; protect secrets in a key-management service; and design software so crypto providers and algorithms can be changed with limited disruption. For post-quantum migration, first discover where public-key algorithms and certificates are used, then test new standards in a controlled migration plan. NIST’s migration work emphasizes discovery and a staged transition to post-quantum cryptography.</p><h3>Mitigate hardware and supply-chain risks — HBOM</h3><p>Confirm the exact component revision, manufacturer and affected product range with the vendor. Apply firmware updates or configuration changes; replace or isolate affected components when updates are unavailable; and plan alternate suppliers or parts for availability risks. Validate substitutions and provenance when receiving parts. Where the root cause is uncertain, preserve evidence and coordinate with the manufacturer rather than asserting a defect based only on a similar part name.</p><h3>Triage before action</h3><p>A sound triage decision combines four questions: (1) Is the component really present? (2) Is the vulnerable feature enabled or reachable? (3) What exposure and business impact follow? (4) What is the safest fix or compensating control? Record the owner, decision, evidence, due date and next review. Use temporary isolation, feature disablement, access limits or monitoring when immediate patching is not feasible, and set an expiry date for temporary controls.</p><h3>8. Best practices</h3><p>· Generate from the released artifact, not only from a developer’s machine. Keep build and scan steps reproducible, and match each BOM to a product name, version and release.</p><p>· Automate updates in CI/CD and at major product changes. Refresh inventories when dependencies, firmware, hardware revisions, certificates or runtime configuration change.</p><p>· State scope and completeness honestly. Identify the scan method, timestamp, tool version, target, known blind spots and whether the BOM is complete, partial or unknown.</p><p>· Use stable identifiers and explicit relationships. Include versions, suppliers and hashes where practical; for hardware, normalize part numbers and revisions. Record where the evidence came from.</p><p>· Protect sensitive data. Do not publish private keys or secrets. Review serials, MAC addresses, supplier locations, internal package names and exploit details before sharing.</p><p>· Validate structure and quality. Check schema conformance, duplicate or ambiguous components, missing versions, unresolved dependencies and unexpected empty inventories.</p><p>· Keep BOMs linked to vulnerability response. Assign finding owners, prioritize based on exposure and impact, track fixes to closure, and add VEX or equivalent status with evidence when findings are not applicable.</p><p>· Maintain an authoritative source and history. Store versioned files with access controls, retention rules and integrity evidence; avoid multiple untracked “latest” copies.</p><p>· Combine supplier evidence with internal discovery. A product SBOM or host HBOM cannot reveal every upstream production fact. Request supplier details and record confidence and provenance.</p><p>· Treat tools as evidence generators, not oracles. Review supported ecosystems, freshness of vulnerability feeds, detection limitations and permission boundaries before relying on results.</p><p>· Plan for change. Assign clear ownership across engineering, security, procurement and operations; define the response path for a vulnerable library, unsafe crypto, hardware recall or supplier interruption</p><h3>A. Quick comparison and glossary</h3><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*RYi-sf-UFi0lztAlRNlpVg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bVHcmXYWY4yH-rkVyZPTAw.png" /></figure><p><strong>The Key takeaway:</strong> By understanding and maintaining these Bills of Materials, organizations can improve visibility, identify vulnerabilities, manage supply chain risks, and make more informed security decisions.</p><p>In today’s evolving threat landscape, adopting the right combination of BOMs is no longer just a good security practice — it’s an important step toward building a more resilient and secure ecosystem</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5a0a580cb06b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Install Frida in Android Device]]></title>
            <link>https://vishvesh71.medium.com/how-to-install-frida-in-android-device-49583edecb64?source=rss-9f671edbd8cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/49583edecb64</guid>
            <category><![CDATA[objection]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[frida]]></category>
            <dc:creator><![CDATA[Aerialist71]]></dc:creator>
            <pubDate>Wed, 17 Mar 2021 17:16:00 GMT</pubDate>
            <atom:updated>2021-03-17T17:16:00.919Z</atom:updated>
            <content:encoded><![CDATA[<p>In this article, I am gonna show to install frida in the Android Device/Emulator. For that we will be requiring a PC running Python 3.7 atleast and an Android Device/Emulator, for emulator I am using Memu Emulator</p><p>Frida helps you to inject your own scripts into black box processes. Hook any function, spy on crypto APIs or trace private application code, no source code needed. Edit, hit save, and instantly see the results. All without compilation steps or program restarts.</p><p>We are basically gonna setup a client server just like we do in the drozer, the client is the android package in the android device and server on the System and by that we communicate and pass all the commands.</p><p>Download Links:</p><ol><li>Frida: <a href="https://github.com/frida/frida/releases">https://github.com/frida/frida/releases</a></li><li>Python: <a href="https://www.python.org/downloads/">https://www.python.org/downloads/</a></li><li>Memu: <a href="https://www.memuplay.com/">https://www.memuplay.com/</a></li></ol><p>Step 1: Open the command prompt where python is located and type the following command “pip install frida” (Make sure pip is installed before this command)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/672/1*yWXzcVsNPFDvWQgU-L5zPQ.png" /></figure><p>Step 2: After installation then type “pip install frida-tools” and a package of frida will get installed on your system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IN9bW8U7YOKTC0xuDE54sg.png" /></figure><p>Step 3: Then install the Objection tool as “pip install objection” which will help in Inspect and interact with container file systems.</p><ul><li>Bypass SSL pinning.</li><li>Dump keychains.</li><li>Perform memory related tasks, such as dumping &amp; patching.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/987/1*GpeyTQwkgFll9kC22vPE9w.png" /></figure><p>Step 4: Go to the above provided link to download the package for the Android Device (Make sure you download the package according to your device architecture otherwise it won’t get install)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y5rECe24dSi2yDj2FwEkNw.png" /></figure><p>Step 5: The below command will help you to find your device architecture. Connect your PC to device using adb and type the following Command “adb shell getprop ro.product.cpu.abi”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/337/1*9IBSiDAI5abddCYFC12kxQ.png" /></figure><p>Step 6: Then Push the downloaded package into the temp folder of your Android Device and then make the file executable by chmod and then run the file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/449/1*wNlWIalP85hEGkK6N0Py0w.png" /></figure><p>As we can see that the frida has been installed and it communicating with the Android Device</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/352/1*mjC4GP5riecp-7cKmAoTyA.png" /></figure><p>In the upcoming blogs we are gonna see how to bypass SSL Pinning, Root Detection Bypass and other exploits related to services and activities…. till then see ya…..</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=49583edecb64" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fixing Vulnerabilities in IIS Server 7.0 , 8.0 , 8.5 and 10.0]]></title>
            <link>https://vishvesh71.medium.com/fixing-vulnerabilities-in-iis-server-7-0-8-0-8-5-and-10-0-7db7b08ce2d7?source=rss-9f671edbd8cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/7db7b08ce2d7</guid>
            <dc:creator><![CDATA[Aerialist71]]></dc:creator>
            <pubDate>Sun, 14 Mar 2021 14:51:19 GMT</pubDate>
            <atom:updated>2021-03-14T14:51:19.408Z</atom:updated>
            <content:encoded><![CDATA[<h3>Fixing Vulnerabilities in IIS Server 7.0 , 8.0 , 8.5 and 10.0</h3><p>Hello Everyone, this is my first security blog and I hope you may find it valuable ….</p><p>In this blog we are gonna jump into <strong>Fixing Low or Info </strong>level vulnerabilities in the IIS Server. I am demonstrating this over my <strong>IIS Server 7.5</strong> and same scenario can be replicated among the other IIS server as they have the same interface</p><h3><strong>VULNERABILITIES:</strong></h3><p>1. Directory Listing/Directory Browsing</p><p>2. METHODS</p><p>3. X-Frame OPTIONS</p><p>4. Server Version</p><p>5. Asp and X-powered Version</p><p>6. HTTPs implementation</p><p>7. Strict-Transport-Policy</p><p>8. X-XSS Protection</p><p>9. CSP (Content Security Policy)</p><p>10. Improper Error</p><p>11. Viewstate unencrypted</p><p>12. Host Header Injection</p><p>13. Weak SSL/TLS ciphers</p><p>14. Cookie Attributes</p><h3><strong>Requirements:</strong></h3><p>1. Windows Machine</p><p>2. IIS Manager (<a href="https://www.microsoft.com/en-in/download/details.aspx?id=2299">https://www.microsoft.com/en-in/download/details.aspx?id=2299</a>)</p><p>3. Postman (to capture request and response) (<a href="https://www.postman.com/">https://www.postman.com/</a>)</p><p>4. Mozilla/Chrome</p><p>5. URL Rewrite Module (<a href="https://www.microsoft.com/en-us/download/details.aspx?id=47337">https://www.microsoft.com/en-us/download/details.aspx?id=47337</a>)</p><p>6. .Net Framework 4.0 (<a href="https://dotnet.microsoft.com/download/dotnet-framework">https://dotnet.microsoft.com/download/dotnet-framework</a>)</p><p><strong>Note:</strong> Kindly restart the server after installing the URL Rewrite Module and <strong>after every changes</strong> we make to the server we need to <strong>Restart</strong> it in order for it to take place.</p><p><strong>1.</strong> <strong>Directory</strong> <strong>Listing/Directory Browsing</strong></p><p>The below screenshot shows the Directories are listed:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/551/1*0IDk3UxrfMgy3D00EBj7Zg.png" /></figure><p>Go to the IIS Manager and select your website and then select the Directory Browsing as shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*FvpgWpPH4VR9dali5UXxbg.png" /></figure><p>As we can see that on the right side there is a Disable button. Select it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*ViC8SGMmiaDQRhoKAqdo5w.png" /></figure><p>As we can see now that the Directories has been disabled</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*sdwCdTpcH1LMKmKrqtiO9A.png" /></figure><p>Now select the Directory Browsing and select the Restart button on the right side as shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*CErYnDe8XPsIpSFy52xCrg.png" /></figure><p>The Directories are now not accessible.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*K7Wu5ZRhaMQpsHq8l-yL8Q.png" /></figure><p><strong>2.</strong> <strong>METHODS</strong></p><p>To disable the Methods such as OPTIONS, TRACE, DELETE etc</p><p>Go to the IIS Manager and select your website and then select the <strong>Request Filtering</strong> as shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*4rTNgYNtDytRXBLQlvmFpg.png" /></figure><p>Now click on the <strong>HTTP Verbs</strong>, we can see on the right side that there is <strong>Allow Verb</strong> and <strong>Deny Verb:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*JgfElzguLg9r_I6PRFU6dQ.png" /></figure><p>Select on the Deny verb and type the OPTIONS and then select OK.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*cwm22mSNhw_jICtDimJ-wg.png" /></figure><p>Similary we can write for Allow verbs as shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*LkIVuHrd9IzcLP7uc2F-FA.png" /></figure><p>The below screenshot shows that the OPTIONS methods is now disabled (404 NOT FOUND):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*ihTi0Vz8qGVv_qFDizY_HQ.png" /></figure><p>Another method is to open the web.config file and write the highlighted rule as shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/609/1*7lXmRHp8vZNi-a-ji6Ew5Q.png" /></figure><p><strong>NOTE: To Restart the Request Filtering service, and web.config file is created when the website gets loaded into the IIS manager and web.config file is located from where the application is accessed.</strong></p><p><strong>3.</strong> <strong>X-Frame Options:</strong></p><p>The below screenshot shows that the X-Frame is set to SAMEORIGIN:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*j4P29ZCgChaw65LDKHDWFQ.png" /></figure><p>Go to the IIS Manager and select your website and then select the <strong>HTTP Response:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*uOjv3JAAUFSK7Mk_hf-dAA.png" /></figure><p>In here we can see that the X-Frame is set to SAMEORIGIN and we have to change it to DENY</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*YdBX9Ah_3DO1CYXYPKfJgw.png" /></figure><p>Select the X-Frame Options and on the right we can see the Edit, click on it and set it to DENY as shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*NKx6R7B_RKTigDIqRo0Qmg.png" /></figure><p>Restart the HTTP response headers so that the changes could take place.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*P87IJ1psTmqJKdr08kwq_A.png" /></figure><p>The X-Frame is now set to DENY</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*00A7EtX9QrWvJRNkhP9Okw.png" /></figure><p>Another method is make changes to the <strong>web.config</strong> file as shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*mGFm1hgrG31nG8GEdS2O2w.png" /></figure><p>Locate the X-Frame Options and set the value from SameOrigin to DENY:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/631/1*7qdHC0Rdu20Ae4MO3-IHYQ.png" /></figure><p>After making the changes save the file and restart the server :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/648/1*hhRwhkotof7GFqEqiuiXRw.png" /></figure><p>The X-Frame is now set to DENY:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/643/1*5_coc3szQ5KphWdanKgy-Q.png" /></figure><p><strong>4.</strong> <strong>Server version disclosure:</strong></p><p>The below screenshot shows that the server version is disclosed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/644/1*7khMK4af3gy_f2B6OfCCaQ.png" /></figure><p>Select your website and click on the <strong>URL Rewrite</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*FuSO52xN7MMcGnWhyiJ0bA.png" /></figure><p>In the URL Rewrite rule, we can see in the top right there is <strong>View Server Variable</strong>, click on it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*GW4Ly_4LfdZabzUv2HbBbA.png" /></figure><p>Then in it click on the Add on the top right and add the server variable as <strong>Response_Server</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*2n_W6YJ_TuJyXtIWJqxI9A.png" /></figure><p>Then go back to the URL Rewrite Module and Click on the <strong>Add Rules</strong> on the Top right corner the following window will appear as shown below:</p><p>Then Click on the <strong>Blank Rule</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*4JuO_0fO6UpVLEf6SqF9JA.png" /></figure><p>Select the following tabs as shown in the below screenshot and make sure to select the <strong>RESPONSE_SERVER</strong> (the server variable we created) and pattern as .* and then click OK:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/673/1*pp13Ttd2t9ysiG0VqWz9PA.png" /></figure><p>The new rule has been created for Hiding the server banner in the response and now restart the server completely so that the changes could take place.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/667/1*FZLoAH_6iDunGJvUn_D2Bw.png" /></figure><p>As we can see that the server banner is hidden in the response.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/635/1*LilxOnbE95bJTF-HTT-yuQ.png" /></figure><p><strong>5.</strong> <strong>Asp version disclosure:</strong></p><p>The below screenshot shows that the Asp version is disclosed:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/647/1*WUG2VA7Wx4oAhyhQAZy9yw.png" /></figure><p>Go to the IIS Manager and select your website and then select the HTTP Response</p><p>Select the <strong>X-Powered-By</strong> and Click on the Remove button as shown in the top right corner:</p><p>Now restart the HTTP response Module so that the changes could take place.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/691/1*F3VGRoixZa-WsqirOw_uMA.png" /></figure><p><strong>Note: Another Method is setting the value of the Header with no version number disclosure</strong></p><p>The Asp version is not disclosed any further anymore.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/632/1*VdTnN-Kx0gI9fTW-gvzE_Q.png" /></figure><p><strong>6.</strong> <strong>HTTPs implementation:</strong></p><p>The below screenshot shows that the website is running on HTTP:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*YNtOyAzBJ0rGI-FzEYRdXQ.png" /></figure><p>Go to the IIS Manager and select the PC Name (In My case its MARK3-PC) above Application Pools where all server settings are managed and then click on the Server certificates.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/641/1*VkY5Xjv6FZ1giCyFWVz8eg.png" /></figure><p>Now click on the <strong>Create Self-Signed Certificates</strong> on the top right corner:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*IOU21Gk8zoS5cD7x0p-2pw.png" /></figure><p>Give the certificate a name ex: <a href="http://www.domain.com/">www.domain.com</a> as shown below and click OK:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*tD6yvt-dkbYTumBTr2CFug.png" /></figure><p>The server certificate has been created now:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*P2PIjZ_mVDDZcaeDIMgHhw.png" /></figure><p>Now select your website and then select the <strong>BINDINGS</strong> on the top right corner</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*ZCYantJ1q_SI-F-adCorHg.png" /></figure><p>Then click on the Add and select the following screenshot and select the certificate we created.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*4UzhUsbQmW5iHtCz6JjwnA.png" /></figure><p>We can see that the HTTPs is added and then click on Close and restart the server.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/621/1*nZdi-Bm23WtgZrRoQS1NDg.png" /></figure><p>We can see the middle right corner that the HTTPs website has been created.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/605/1*qZB5ihCZhoW9AH-yltLCug.png" /></figure><p>We can see that the website runs on HTTPs:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/341/1*iLlPTjxjKOHZDB6MHLz1ww.png" /></figure><p><strong>7.</strong> <strong>Strict-Transport-Policy</strong></p><p>The below screenshot shows that the Strict-Transport-Policy has not set</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*K51Mvc-LQzB2Qgd2pp9imw.png" /></figure><p>Go to the IIS Manager and select your website and then select the <strong>HTTP Response</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*DHi9u6s2OhkI68sT-K7BOA.png" /></figure><p>Then click on Add on the top right corner</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/655/1*JHVCsSYH95yzFyUUP9u1VA.png" /></figure><p>Set the name and value of the Header as shown below and click OK and then restart the HTTP Response Header server:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/664/1*MOk3uWg6o_-siAM6sBK0xA.png" /></figure><p>Now we can see that the Strict-Transport-Policy has been set:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*keW52Dg_SwNl-9FPkosM0g.png" /></figure><p><strong>8.</strong> <strong>X-XSS Protection</strong></p><p>The below screenshot shows that the X-XSS Protection has not set:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*K51Mvc-LQzB2Qgd2pp9imw.png" /></figure><p>Go to the IIS Manager and select your website and then select the HTTP Response:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*DHi9u6s2OhkI68sT-K7BOA.png" /></figure><p>Set the name and value of the Header as shown below and click OK and then restart the HTTP Response Header server:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/645/1*BF8MBRj_6meKGMCPxZcGXA.png" /></figure><p>Now we can see that the X-XSS Protection has been set:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*cYSjbOW6BdJQ-EmI5M3XpA.png" /></figure><p><strong>9.</strong> <strong>Content-Security-Policy:</strong></p><p>The below screenshot shows that the CSP has not set:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*K51Mvc-LQzB2Qgd2pp9imw.png" /></figure><p>Add this to the web.config file and restart the server or else we can add the Header from the HTTP response module.</p><p><strong>Note: If CSP is not properly configured the website can get crash or can face Login issues.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*ft6vo9C-qyByZXOjc4QbfQ.png" /></figure><p>We can see that the CSP has been set:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/644/1*15UqRHDAlv2BpNkrQ7zovQ.png" /></figure><p><strong>10.</strong> <strong>Improper Error:</strong></p><p>The below screenshot shows the error page and we can customize it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/648/1*2rhOkwMNUNpQhqMIdnpkRA.png" /></figure><p>Go to the IIS Manager and select your website and then select the <strong>Error Pages</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/652/1*HuQQC52Uham268eMdCjQlA.png" /></figure><p>We can see that each Status Code has a path associated with it which is the error page of the server.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/663/1*svMjGBFjqQ8P-9fpj8rmnw.png" /></figure><p>For ex: Status Code 404 has its path and when we get 404 error the information is revealed according to the customized path</p><p>Here we can set the path of the designed error page or redirect to the new URL by selecting on of the following option:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/613/1*_Tt1QIjjrIuBAJHLY4fDMA.png" /></figure><p><strong>Note: The customized error page should be kept in the folder of the website and proper path should be given to each Status Code</strong>.</p><p>The Error page is kept inside the website folder as shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/520/1*MbH2kvqR-iFTPC6C3HCSbA.png" /></figure><p>Another method is to open the web.config file and write the below code and restart the server this will redirect the particular status code to the customized error page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*CHfF08blAs1v4q__5uvkDg.png" /></figure><p>The customized error page for 404 Status Code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*ndfpt-vPOdD8fdN5WQcg-w.png" /></figure><p><strong>11.</strong> <strong>View State Unencrypted:</strong></p><p>The below screenshot shows that the viewstate is unencrypted :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*3t1m1rKDXzUV8I7TnSxYqQ.png" /></figure><p>Go to the web.config file of the website change the below code highlighted below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/565/1*PzqTGRdT-8fHNEZDB1ETBg.png" /></figure><p>In the above highlighted code add the following as <strong>viewStateEncryptionMode=”Always” </strong>and restart the server.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*APV2rq7Ja7y4BZIZRctH5g.png" /></figure><p><strong>12.</strong> <strong>Host-Header Injection</strong></p><p>URL Rewrite rules can be used to find malicious host headers:</p><ol><li>Click on the site in IIS Manager</li><li>Go to “<strong>URL Rewrite</strong>”</li><li>Click “<strong>Add Rule(s)</strong>”</li><li>Select “<strong>Blank rule</strong>”</li><li>For “<strong>Match URL</strong>” section, enter <strong>(.)</strong> into the “<strong>Pattern</strong>”</li><li>In “<strong>Conditions</strong>” section, click “<strong>Add</strong>”</li><li>Enter <strong>{HTTP_HOST}</strong> into “<strong>Condition input</strong>”</li><li>Select “<strong>Does Not Match the Pattern</strong>” from “<strong>Check if input string</strong>” list</li><li>Enter <strong>^([a-zA-Z0–9-_]+.)domain.com$</strong> into “<strong>Pattern</strong>” field (change domain name with yours)</li><li>For the “<strong>Action</strong>” section, select “<strong>Redirect</strong>” from the “<strong>Action type</strong>” list</li><li>Enter your domain address (<a href="https://nam06.safelinks.protection.outlook.com/?url=https%3A%2F%2Fdomain.com%2F&amp;data=02%7C01%7CNedim.Sahin%40microsoft.com%7Cd2de40c566894e36236108d76fa20dbd%7C72f988bf86f141af91ab2d7cd011db47%7C1%7C0%7C637100614111289213&amp;sdata=4TNx%2FH2R8D8DMTdvc75WVvHB4NVUT7HGdLjI6gmqjwY%3D&amp;reserved=0">https://domain.com/</a>) in the “<strong>Redirect URL</strong>”</li><li>Select “<strong>Permanent (301)</strong>” from the “<strong>Redirect type</strong>” list</li><li>Click “<strong>Apply</strong>”</li></ol><p>For fixing the host header injection:</p><p>Click on the site in IIS Manager and then go to <strong>URL Rewrite</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/605/1*5dujt8TkRWJvp5uCk6wULQ.png" /></figure><p>Then click on Add rule and then on the <strong>Inbound Blank rule</strong> as shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/609/1*5nVUis20T4n3-okUQ94uJQ.png" /></figure><p>Give the Rule name as Host Header Validation and Pattern as .(Dot)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*QzaVXOw3bbHYNPvHSsBxqA.png" /></figure><p>Then scroll down in the same rule and click on the <strong>Conditions</strong> and add a rule:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*UMci_axvdJ_v2TVPQs4syQ.png" /></figure><p>The rule in the condition is as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/479/1*hPgPfygvvo8lniaF0gCY6w.png" /></figure><p>After writing the rule, Select OK.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/611/1*qxCuZHWh6Z4TWNhGrElcTg.png" /></figure><p>Now scroll down below in the same rule and select the following things as shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/603/1*bn-TuXfTIqQM7_mFRDVOow.png" /></figure><p>Then apply these rule and restart the URL Rewrite Module and we can see the rule below as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/639/1*aDIBUbRdCRw0aCuy27NJSQ.png" /></figure><p>Alternate Method: Select the website and click on the Bindings on the top right corner and select Hostname as your website name as shown below and restart the server.</p><p>Note: This method doesn’t work sometimes it varies from Server to Server</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*gy4VjjYwFGgMs_bRqGOdlw.png" /></figure><p><strong>13.</strong> <strong>Weak SSL/TLS ciphers</strong></p><p>1. Click <strong>Start</strong>, click <strong>Run</strong>, type regedt32 or type regedit, and then click <strong>OK</strong>.</p><p>2. In Registry Editor, locate the following registry key:<br> <br> <strong>HKey_Local_Machine\System\CurrentControlSet\Control\SecurityProviders \SCHANNEL\Protocols\PCT 1.0\Server</strong></p><p>3. On the <strong>Edit</strong> menu, click <strong>Add Value</strong>.</p><p>4. In the <strong>Data Type</strong> list, click <strong>DWORD</strong>.</p><p>5. In the <strong>Value Name</strong> box, type Enabled, and then click <strong>OK</strong>.<br> Note If this value is present, double-click the value to edit its current value.</p><p>6. Type <strong>00000000</strong> in Binary Editor to set the value of the new key equal to “0”.</p><p>7. Click <strong>OK</strong>. Restart the computer.</p><p>Go to the regedit and select the following Highlighted path and from there enable or disable the weak ciphers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/574/1*c_VBfy139JQBjJsPhpfh0g.png" /></figure><p>To enable the particular cipher Double click on it and set value as <strong>“Enable”</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/359/1*_aPB2Tce9iLBJNI6rUN5mg.png" /></figure><p><strong>14.</strong> <strong>Cookie Attributes.</strong></p><p>The main Attributes are secure, httponly and path attribute. Since my application doesn’t have cookies because it’s not an Asp.net application the following remediation will work on them.</p><p><strong>A.</strong> <strong>Secure Attribute:</strong></p><p>Add this to web.config file and restart the server:</p><p>&lt;configuration&gt;<br> &lt;system.web&gt;<br> &lt;! — Force secure connections for all Cookies →<br> &lt;httpCookies <strong>requireSSL=”true”</strong> /&gt;<br> &lt;/system.web&gt;<br> &lt;/configuration&gt;</p><p><strong>B.</strong> <strong>HttpOnly Attribute:</strong></p><p>Add this to web.config file and restart the server:</p><p>&lt;configuration&gt;<br> &lt;system.web&gt;<br> &lt;! — Prevent client script from reading Cookies →<br> &lt;httpCookies <strong>httpOnlyCookies=”true”</strong> /&gt;<br> &lt;/system.web&gt;<br> &lt;/configuration&gt;</p><p><strong>C.</strong> <strong>Path Attribute:</strong></p><p>Add this to web.config file and restart the server:</p><p>&lt;configuration&gt;<br> &lt;appSettings&gt;<br> &lt;add <strong>key=”UserDefiniedCookiePathFilter”<br> value=”/VirtualDirectoryToFilter”</strong>/&gt;<br> &lt;/appSettings&gt;<br> &lt;/configuration&gt;</p><p><strong>D.</strong> <strong>SameSite to avoid cross-site request forgery:</strong></p><p>&lt;system.webServer&gt;</p><p>&lt;rewrite&gt;</p><p>&lt;outboundRules&gt;</p><p>&lt;clear /&gt;</p><p>&lt;rule name=”Add SameSite” preCondition=”No SameSite”&gt;</p><p>&lt;match serverVariable=”RESPONSE_Set_Cookie” pattern=”.*” negate=”false” /&gt;</p><p>&lt;action type=”Rewrite” value=”{R:0}; SameSite=lax” /&gt;</p><p>&lt;/rule&gt;</p><p>&lt;preConditions&gt;</p><p>&lt;preCondition name=”No SameSite”&gt;</p><p>&lt;add input=”{RESPONSE_Set_Cookie}” pattern=”.” /&gt;</p><p>&lt;add input=”{RESPONSE_Set_Cookie}” pattern=”; SameSite=lax” negate=”true” /&gt;</p><p>&lt;/preCondition&gt;</p><p>&lt;/preConditions&gt;</p><p>&lt;/outboundRules&gt;</p><p>&lt;/rewrite&gt;</p><p>…</p><p>&lt;/system.webServer&gt;</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7db7b08ce2d7" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>