<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>XPN Infosec Blog</title><link>https://blog.xpnsec.com/</link><description>Recent content on XPN Infosec Blog</description><generator>Hugo</generator><language>en-gb</language><lastBuildDate>Sat, 25 Jul 2026 19:19:16 +0000</lastBuildDate><atom:link href="https://blog.xpnsec.com/index.xml" rel="self" type="application/rss+xml"/><item><title>Jailbreaking Local Models with JSON</title><link>https://blog.xpnsec.com/articles/#jailbreaking-local-models-with-json</link><pubDate>Sat, 25 Jul 2026 19:19:16 +0000</pubDate><guid>https://blog.xpnsec.com/articles/jailbreaking-local-models-with-json/</guid><description>This article demonstrates how to jailbreak local models using constrained decoding.</description></item><item><title>Benchmarking Malicious Agents</title><link>https://blog.xpnsec.com/articles/#benchmarking-malicious-agent</link><pubDate>Thu, 16 Jul 2026 19:19:16 +0000</pubDate><guid>https://blog.xpnsec.com/articles/benchmarking-malicious-agent/</guid><description>In this article, we're going to look at how we benchmark the performance of our agent, and improve this capability with the macOS 27 Evaluations framework.</description></item><item><title>Extracting creds with Foundation Model</title><link>https://blog.xpnsec.com/articles/#extracting-creds</link><pubDate>Mon, 13 Jul 2026 19:19:16 +0000</pubDate><guid>https://blog.xpnsec.com/articles/extracting-creds/</guid><description>This article shows the power of macOS 27's new foundation model and OCR model for extracting credentials.</description></item><item><title>The Accidental C2 - Exploring Dev Tunnels for Remote Access</title><link>https://blog.xpnsec.com/accidental-c2/</link><pubDate>Sat, 09 May 2026 19:19:16 +0000</pubDate><guid>https://blog.xpnsec.com/accidental-c2/</guid><description>Dev Tunnels aren’t “just port forwarding”. They consist of layers of embedded protocols with RPC messages being exchanged. Once you peel the layers, you quickly see how Dev Tunnels are a C2 framework with extra steps.</description></item><item><title>An Evening with Claude (Code)</title><link>https://blog.xpnsec.com/an-evening-with-claude-code/</link><pubDate>Sat, 29 Nov 2025 19:19:16 +0000</pubDate><guid>https://blog.xpnsec.com/an-evening-with-claude-code/</guid><description>A deep dive into discovering CVE-2025-64755, a vulnerability in Claude Code v2.0.25. This post walks through the process of reversing the obfuscated Claude Code JavaScript, and exploiting weak regex expressions to achieve code execution unprompted.</description></item><item><title>Administrator Protection Review</title><link>https://blog.xpnsec.com/administrator-protection/</link><pubDate>Fri, 20 Jun 2025 23:01:46 +0000</pubDate><guid>https://blog.xpnsec.com/administrator-protection/</guid><description>Microsoft will be introducing Administrator Protection into Windows 11, so I wanted to have an understanding of how this technology works and how it interacts with existing offensive tooling. While this technology is just a thin wrapper around a separate account, there are a few nuances such as who is permitted to access these accounts, as well as existing UAC bypasses which are still effective against the new "backdoorless" Administrator Protection. This post explores these nuances in detail.</description></item><item><title>Tokenization Confusion</title><link>https://blog.xpnsec.com/tokenization-confusion/</link><pubDate>Wed, 04 Jun 2025 23:01:46 +0000</pubDate><guid>https://blog.xpnsec.com/tokenization-confusion/</guid><description>In this post we look at the new Prompt Guard 2 model from Meta, and introduce a concept I've been calling "Tokenization Confusion" which aims to confuse Unigram tokenization into generating tokens which will result in the misclassification of malicious prompts. We'll also look at why building up our ML knowledge will lead to better findings when assessing LLM API’s, as I discovered during a flight across the Atlantic.</description></item><item><title>The SQL Server Crypto Detour</title><link>https://blog.xpnsec.com/the-sql-server-crypto-detour/</link><pubDate>Wed, 16 Apr 2025 23:01:46 +0000</pubDate><guid>https://blog.xpnsec.com/the-sql-server-crypto-detour/</guid><description>One of the things that I love about my role at SpecterOps is getting to dig into various technologies and seeing the resulting research being used in real-time. This post will explore one such story of how I was able to go from a simple request of recovering credentials from a database backup, to reverse engineering how SQL Server encryption works, finding some new methods of brute-forcing database encryption keys.. and finally identifying a mistake in ManageEngine’s ADSelfService product which allows encrypted database backups to reveal privileged credentials.</description></item><item><title>ADFS - Living in the Legacy of DRS</title><link>https://blog.xpnsec.com/adfs-living-in-the-legacy-of-drs/</link><pubDate>Sun, 12 Jan 2025 23:01:46 +0000</pubDate><guid>https://blog.xpnsec.com/adfs-living-in-the-legacy-of-drs/</guid><description>In this post we’re going to focus on some ADFS internals. We’ll be looking at OAuth2, and how it underpins the analogues to Entra ID security features like Device Registration and Primary Refresh Tokens.</description></item><item><title>Identity Providers for RedTeamers</title><link>https://blog.xpnsec.com/identity-providers-redteamers/</link><pubDate>Mon, 18 Mar 2024 23:01:46 +0000</pubDate><guid>https://blog.xpnsec.com/identity-providers-redteamers/</guid><description>Originally presented at SOCON-2024, and continuing the series into post-exploitation techniques against Identity Providers, in this blog post we'll look at Ping, OneLogin and Entra ID. I'll discuss how post-exploitation techniques effective against Okta apply to other providers, release new tools for post-exploitation, and look at what proves to be effective when critical assets lie beyond an Identity Provider portal.</description></item><item><title>MacOS "DirtyNIB" Vulnerability</title><link>https://blog.xpnsec.com/dirtynib/</link><pubDate>Wed, 04 Oct 2023 23:01:46 +0000</pubDate><guid>https://blog.xpnsec.com/dirtynib/</guid><description>While looking for avenues of injecting code into platform binaries back in macOS Monterey, I was able to identify a vulnerability which allowed the hijacking of Apple application entitlements. Recently I decided to revisit this vulnerability after a long time of trying to have it patched, and was surprised to see that it still works. There are some caveats introduced with later versions of macOS which we will explore, but in this post we’ll look at a vulnerability in macOS Sonoma which has been around for a long time, and remains an 0day, urm, to this day.</description></item><item><title>Okta for Red Teamers</title><link>https://blog.xpnsec.com/okta-for-redteamers/</link><pubDate>Mon, 02 Oct 2023 20:01:46 +0000</pubDate><guid>https://blog.xpnsec.com/okta-for-redteamers/</guid><description>In this blog post, I'll discuss some of the post-exploitation techniques that I've found to be useful against Okta. Specifically, this post will look at how to use delegated authentication to our advantage, silver tickets, Okta AD agent spoofing, and finally how to deploy a fake SAML provider.</description></item><item><title>LAPS 2.0 Internals</title><link>https://blog.xpnsec.com/lapsv2-internals/</link><pubDate>Sun, 13 Aug 2023 10:03:31 +0000</pubDate><guid>https://blog.xpnsec.com/lapsv2-internals/</guid><description>This year, LAPS 2.0 was released by Microsoft, and thankfully it now comes built-in to Windows. This time it comes ready for use with Active Directory, as well as being supported in Azure AD aka Entra ID. In this post, we’ll look at how LAPS 2.0 for Active Directory works under the hood, so you can make those fresh recommendations to your clients, and prepare yourself for the inevitable question... “But we just deployed LAPS.. what does LAPS 2.0 do differently?!”.</description></item><item><title>PNG Steganography from First Principles</title><link>https://blog.xpnsec.com/png-steganography/</link><pubDate>Wed, 09 Aug 2023 10:03:31 +0000</pubDate><guid>https://blog.xpnsec.com/png-steganography/</guid><description>Steganography is experiencing a revival as a wrapper for delivering payloads. In this post we'll go back to basics and show just how steganography can be applied to a PNG image using the common least significant bit (LSB) encoding technique. No magic... just raw information... and a little C++.</description></item><item><title>Building a Custom Mach-O Memory Loader for macOS - Part 1</title><link>https://blog.xpnsec.com/building-a-mach-o-memory-loader-part-1/</link><pubDate>Sat, 04 Feb 2023 10:03:31 +0000</pubDate><guid>https://blog.xpnsec.com/building-a-mach-o-memory-loader-part-1/</guid><description>In this blog we'll look at what it takes to construct an in-memory loader for Mach-O bundles within MacOS Ventura without using dyld. We'll walk though the lower-level details of what makes up a Mach-O file, how dyld processes load commands to map areas into memory, and how we can emulate this to avoid writing payloads to disk.</description></item><item><title>Restoring Dyld Memory Loading</title><link>https://blog.xpnsec.com/restoring-dyld-memory-loading/</link><pubDate>Sat, 14 Jan 2023 12:03:31 +0000</pubDate><guid>https://blog.xpnsec.com/restoring-dyld-memory-loading/</guid><description>Up until recently, we've enjoyed in-memory loading of Mach-O bundles courtesy of dyld and its NSCreateObjectFileImageFromMemory/NSLinkModule API methods. And while these methods still exist today, there is a key difference.. memory modules are now persisted to disk. So in this post we'll take a look at just what was changed in dyld, and see what we can do to restore this functionality... hopefully keeping our warez in memory for a little longer.</description></item><item><title>WAM BAM - Recovering Web Tokens From Office</title><link>https://blog.xpnsec.com/wam-bam/</link><pubDate>Mon, 17 Oct 2022 17:40:29 +0000</pubDate><guid>https://blog.xpnsec.com/wam-bam/</guid><description>This post looks at the recent trend of pulling Azure tokens from Office process memory and tries to identify just how these tokens were loaded, how Office handles a Microsoft Account (MSA), and how we can recover cached credentials from the Token Broker Cache.</description></item><item><title>Exploring SCCM by Unobfuscating Network Access Accounts</title><link>https://blog.xpnsec.com/unobfuscating-network-access-accounts/</link><pubDate>Sat, 09 Jul 2022 23:00:00 +0000</pubDate><guid>https://blog.xpnsec.com/unobfuscating-network-access-accounts/</guid><description>In this post we'll explore just how SCCM uses its HTTP API to initialise a client, take a look at how Network Access Accounts are retrieved from SCCM, and see how we can decrypt these credentials without having to go anywhere near DPAPI.</description></item><item><title>g_CiOptions in a Virtualized World</title><link>https://blog.xpnsec.com/gcioptions-in-a-virtualized-world/</link><pubDate>Sun, 15 May 2022 06:43:29 +0000</pubDate><guid>https://blog.xpnsec.com/gcioptions-in-a-virtualized-world/</guid><description>With the leaking of code signing certificates and exploits for vulnerable drivers becoming common occurrences, adversaries are adopting the kernel as their new playground. And with Microsoft making technologies like Virtualization Based Security (VBS) and Hypervisor Code Integrity (HVCI) available, I wanted to take some time to understand just how vulnerable endpoints are when faced with an attacker set on escaping to Ring-0.</description></item><item><title>NTLMquic</title><link>https://blog.xpnsec.com/ntlmquic/</link><pubDate>Mon, 11 Apr 2022 03:00:00 +0000</pubDate><guid>https://blog.xpnsec.com/ntlmquic/</guid><description>In this post, we'll dig into just how SMB over QUIC works, answer some of the immediate questions around which attacks are feasible, and show how we can repurpose some existing tooling to capture NTLM handshakes.</description></item><item><title>Object Overloading</title><link>https://blog.xpnsec.com/object-overloading/</link><pubDate>Tue, 15 Feb 2022 20:01:46 +0000</pubDate><guid>https://blog.xpnsec.com/object-overloading/</guid><description>In this post we are going to look at one such technique that I thought was cool while playing around with the Windows Object Manager, and which should allow us to load an arbitrary DLL of our creation into a Windows process during initial execution, something that I've been calling "Object Overloading" for reasons which will hopefully become apparent in this post.</description></item><item><title>Weird Ways to Run Unmanaged Code in .NET</title><link>https://blog.xpnsec.com/weird-ways-to-execute-dotnet/</link><pubDate>Wed, 05 May 2021 08:40:46 +0000</pubDate><guid>https://blog.xpnsec.com/weird-ways-to-execute-dotnet/</guid><description>Recently I've been looking at the .NET CLR internals and wanted to understand what further techniques may be available for executing unmanaged code from the managed runtime. This post contains a snipped of some of the weird techniques that I found.</description></item><item><title>Azure Application Proxy C2</title><link>https://blog.xpnsec.com/azure-application-proxy-c2/</link><pubDate>Sat, 24 Apr 2021 13:01:02 +0000</pubDate><guid>https://blog.xpnsec.com/azure-application-proxy-c2/</guid><description>In this post, we are going to look at the Application Proxy protocol, how it works, and show how we can recreate enough functionality to allow us to create a custom inbound proxy into a client environment for our C2 traffic.</description></item><item><title>Tailoring Cobalt Strike on Target</title><link>https://blog.xpnsec.com/tailoring-cobalt-strike-on-target/</link><pubDate>Thu, 04 Feb 2021 14:16:07 +0000</pubDate><guid>https://blog.xpnsec.com/tailoring-cobalt-strike-on-target/</guid><description>We've all been there, you've completed your initial recon, sent in your emails to gather those leaked HTTP headers, spent an age configuring your malleable profile to be just right, set up your CDNs and spun up your redirectors. Then it's time, you send in your email aaaaaand... nothing.</description></item><item><title>Bring Your Own VM - Mac Edition</title><link>https://blog.xpnsec.com/bring-your-own-vm-mac-edition/</link><pubDate>Mon, 28 Dec 2020 10:53:00 +0000</pubDate><guid>https://blog.xpnsec.com/bring-your-own-vm-mac-edition/</guid><description>For a while I've wanted to explore the concept of leveraging a virtual machine on target during an engagement. The thought of having implant logic self-contained and running under a different OS to the base seems pretty interesting. But more so, I've been curious as to just how far traditional AV and EDR can go to detect malicious activity when running from a different virtual environment. While this is a nice idea, the issues with creating this type of malware are obvious, with increased comple...</description></item><item><title>The .NET Export Portal</title><link>https://blog.xpnsec.com/the-net-export-portal/</link><pubDate>Tue, 24 Nov 2020 09:10:00 +0000</pubDate><guid>https://blog.xpnsec.com/the-net-export-portal/</guid><description>While working on some tooling recently I revisited the topic of .NET unmanaged exports and wanted to know just why this works in the way that it does. After all, by now we've all seen the COM calls required to spin up the CLR, so what makes unmanaged exports so special?</description></item><item><title>We Need To Talk About MACL</title><link>https://blog.xpnsec.com/we-need-to-talk-about-macl/</link><pubDate>Sun, 18 Oct 2020 16:24:00 +0000</pubDate><guid>https://blog.xpnsec.com/we-need-to-talk-about-macl/</guid><description>If you've never heard of MACL on MacOS, you're not alone. This obscure feature is a hidden part of MacOS that underpins Apple's concept of User-Intent, a shift in focus for MacOS privacy controls in an attempt to stop endless prompts interrupting the user. And by now we all understand just how annoying these alerts can be to us attackers. Being able to operate on an endpoint without giving the game away is of course essential, and unfortunately staying under the radar on MacOS is getting toughe</description></item><item><title>MacOS Injection via Third Party Frameworks</title><link>https://blog.xpnsec.com/macos-injection-via-third-party-frameworks/</link><pubDate>Wed, 23 Sep 2020 00:05:59 +0000</pubDate><guid>https://blog.xpnsec.com/macos-injection-via-third-party-frameworks/</guid><description>In this post, we are going to take a look at a couple of interesting methods of leveraging third-party technologies to achieve our code injection goals. For us, this translates to running code in the context of a target application without having to resort to disabling SIP.</description></item><item><title>Debugging into .NET</title><link>https://blog.xpnsec.com/debugging-into-net/</link><pubDate>Mon, 10 Aug 2020 01:00:00 +0000</pubDate><guid>https://blog.xpnsec.com/debugging-into-net/</guid><description>.NET for post-exploitation is here to stay. It has been bundled with most C2 frameworks, common tools have been ported, AMSI has been added (then bypassed) and new and clever ways have been found to launch unmanaged code. The process of loading a .NET assembly however appears to be pretty consistent. We know that tools like Cobalt Strike's execute-assembly have greatly increased the accessibility of loading a .NET assembly from memory, with most attackers using this in one way or another during</description></item><item><title>Hiding your .NET - COMPlus_ETWEnabled</title><link>https://blog.xpnsec.com/hiding-your-dotnet-complus-etwenabled/</link><pubDate>Sat, 06 Jun 2020 00:04:30 +0000</pubDate><guid>https://blog.xpnsec.com/hiding-your-dotnet-complus-etwenabled/</guid><description>It turns out that there is a method of disabling ETW in .NET, strangely exposed by setting an environment variable of COMPlus_ETWEnabled=0. This post explores how this works.</description></item><item><title>Designing The Adversary Simulation Lab</title><link>https://blog.xpnsec.com/designing-the-adversary-simulation-lab/</link><pubDate>Sat, 18 Apr 2020 13:31:06 +0000</pubDate><guid>https://blog.xpnsec.com/designing-the-adversary-simulation-lab/</guid><description>In this post we will walk you through the technology used to create and deploy the ActiveBreach Adversary Simulation Lab, and look at the hurdles we jumped through to get things running smoothly.</description></item><item><title>Hiding your .NET - ETW</title><link>https://blog.xpnsec.com/hiding-your-dotnet-etw/</link><pubDate>Tue, 17 Mar 2020 23:57:20 +0000</pubDate><guid>https://blog.xpnsec.com/hiding-your-dotnet-etw/</guid><description>In this post we will focus on Event Threading for Windows (ETW), how it is used to surface events on .NET assemblies, and how we can evade this kind of detection.</description></item><item><title>AWS Lambda Redirector</title><link>https://blog.xpnsec.com/aws-lambda-redirector/</link><pubDate>Tue, 25 Feb 2020 12:09:00 +0000</pubDate><guid>https://blog.xpnsec.com/aws-lambda-redirector/</guid><description>In this post we will be looking at AWS Lambda, how we can deploy code using the Serverless framework, and how we can use this technology as a redirector for Cobalt Strike</description></item><item><title>Testing your RedTeam Infrastructure</title><link>https://blog.xpnsec.com/testing-redteam-infra/</link><pubDate>Tue, 28 Jan 2020 19:47:05 +0000</pubDate><guid>https://blog.xpnsec.com/testing-redteam-infra/</guid><description>As RedTeaming has grown with the industry, so has our need to build dependable environments. In keeping with the cat-and-mouse game we find ourselves in, it's essential to possess the capability of maintaining robust infrastructure which can be recreated if discovered, and more importantly, we need to ensure that the environment is free of issues upon deployment. Today I'm kicking off the first of a series of posts where we will be adopting some of the practices made popular by the DevOps team</description></item><item><title>MacOS Filename Homoglyphs Revisited</title><link>https://blog.xpnsec.com/macos-filename-homoglyphs-revisited/</link><pubDate>Tue, 10 Dec 2019 11:59:31 +0000</pubDate><guid>https://blog.xpnsec.com/macos-filename-homoglyphs-revisited/</guid><description>Last year I posted a few tricks to help when targeting MacOS users, and included a technique useful for spoofing file extensions with the aim of taking advantage of Finder's removal of the .app extension from certain filenames.</description></item><item><title>Protecting Your Malware with blockdlls and ACG</title><link>https://blog.xpnsec.com/protecting-your-malware/</link><pubDate>Mon, 04 Nov 2019 09:42:45 +0000</pubDate><guid>https://blog.xpnsec.com/protecting-your-malware/</guid><description>In Cobalt Strike, blockdlls was introduced to allow protection of spawned processes from non-Microsoft signed DLL's. In this post I will show just how this works, and look at an additional process security option which could help us to deter endpoint security products.</description></item><item><title>Bypassing MacOS Privacy Controls</title><link>https://blog.xpnsec.com/bypassing-macos-privacy-controls/</link><pubDate>Mon, 23 Sep 2019 06:17:49 +0000</pubDate><guid>https://blog.xpnsec.com/bypassing-macos-privacy-controls/</guid><description>Encountering Apple devices during RedTeam engagements is becoming increasingly common, so it's useful to have a few techniques available when navigating around whatever privacy or security changes are introduced with each version of MacOS. When MacOS Mojave rolled out at the end of 2018, a set of privacy restrictions were introduced to alert a user when an application requested access to sensitive data, such as the camera, microphone, address book, calendar etc.. And as (more often than not) o</description></item><item><title>Inter-Realm Key Roasting (well... within the first 30 days)</title><link>https://blog.xpnsec.com/inter-realm-key-roasting/</link><pubDate>Fri, 06 Sep 2019 11:06:35 +0000</pubDate><guid>https://blog.xpnsec.com/inter-realm-key-roasting/</guid><description>In this blog post we will look at a somewhat familiar, but extremely limited window of opportunity which may come in handy when reviewing a fresh Active Directory forest deployment.</description></item><item><title>Analysing RPC With Ghidra and Neo4j</title><link>https://blog.xpnsec.com/analysing-rpc-with-ghidra-neo4j/</link><pubDate>Thu, 01 Aug 2019 06:43:29 +0000</pubDate><guid>https://blog.xpnsec.com/analysing-rpc-with-ghidra-neo4j/</guid><description>Hunting for new lateral movement techniques or interesting ways to execute code can be a nice way to sink some free time. With Windows spawning numerous RPC services on boot, finding unusual execution techniques is sometimes as simple as scratching just below the surface. And often the payoff far outweighs the time to discovery, with SOC or EDR vendors focusing on the more common published techniques, identifying a new way to introduce code execution on a host can throw a spanner in the works of</description></item><item><title>Evading Sysmon DNS Monitoring</title><link>https://blog.xpnsec.com/evading-sysmon-dns-monitoring/</link><pubDate>Sat, 15 Jun 2019 22:48:05 +0000</pubDate><guid>https://blog.xpnsec.com/evading-sysmon-dns-monitoring/</guid><description>In a recent update to Sysmon, a new feature was introduced allowing the ability to log DNS events. While this gives an excellent datapoint for defenders (shout out to the SysInternals team for continuing to provide and support these awesome tools for free), for us as attackers, this means that should our implant or payloads attempt to communicate via DNS, BlueTeam have a potential way to pick up on indicators which could lead to de</description></item><item><title>Exploring Mimikatz - Part 2 - SSP</title><link>https://blog.xpnsec.com/exploring-mimikatz-part-2/</link><pubDate>Fri, 07 Jun 2019 08:24:10 +0000</pubDate><guid>https://blog.xpnsec.com/exploring-mimikatz-part-2/</guid><description>If you haven't had a chance to check it out, take a look here. Continuing on, in this post we will review what has become a nice way of subverting security controls added by Microsoft to prevent dumping of credentials, as well as extracting credentials as they are provided by a victim.</description></item><item><title>Exploring Mimikatz - Part 1 - WDigest</title><link>https://blog.xpnsec.com/exploring-mimikatz-part-1/</link><pubDate>Fri, 10 May 2019 07:10:40 +0000</pubDate><guid>https://blog.xpnsec.com/exploring-mimikatz-part-1/</guid><description>We’ve packed it, we’ve wrapped it, we’ve injected it and powershell’d it, and now we've settled on feeding it a memory dump, and still Mimikatz remains the tool of choice when extracting credentials from lsass on Windows systems. Of course this is due to the fact that with each new security control introduced by Microsoft, GentilKiwi always has a trick or two up his sleeve. If you have ever looked at the effort that goes into Mimikatz, this is no easy task, with</description></item><item><title>Silencing Cylance: A Case Study in Modern EDRs</title><link>https://blog.xpnsec.com/silencing-cylance-a-case-study-in-modern-edrs/</link><pubDate>Thu, 18 Apr 2019 23:21:06 +0000</pubDate><guid>https://blog.xpnsec.com/silencing-cylance-a-case-study-in-modern-edrs/</guid><description>In this blog post we will explore some of our findings that might assist red teamers operating in environments where CylancePROTECT is in place and briefly touch on CylanceOPTICS, a complementary solution that provides rule based detection to the endpoint.</description></item><item><title>Building, Modifying, and Packing with Azure DevOps</title><link>https://blog.xpnsec.com/building-modifying-packing-devops/</link><pubDate>Mon, 11 Mar 2019 18:54:07 +0000</pubDate><guid>https://blog.xpnsec.com/building-modifying-packing-devops/</guid><description>In this post I will be showing how to build a Azure DevOps pipeline for .NET projects, and hopefully show some techniques which I have found useful to modify build artifacts to make them a bit different, and in some cases, to increase the time it takes to analyse our tools if detected by Blue Team.</description></item><item><title>Azure AD Connect for Red Teamers</title><link>https://blog.xpnsec.com/azuread-connect-for-redteam/</link><pubDate>Mon, 18 Feb 2019 08:50:46 +0000</pubDate><guid>https://blog.xpnsec.com/azuread-connect-for-redteam/</guid><description>With clients increasingly relying on cloud services from Azure, one of the technologies that has been my radar for a while is Azure AD. For those who have not had the opportunity to work with this, the concept is simple, by extending authentication beyond on-prem Active Directory, users can authenticate with their AD credentials against Microsoft services such as Azure, Office365, Sharepoint, and hundreds of third</description></item><item><title>How to Argue like Cobalt Strike</title><link>https://blog.xpnsec.com/how-to-argue-like-cobalt-strike/</link><pubDate>Mon, 28 Jan 2019 08:11:44 +0000</pubDate><guid>https://blog.xpnsec.com/how-to-argue-like-cobalt-strike/</guid><description>In Cobalt Strike 3.13, the argue command was introduced as a way of taking advantage of argument spoofing. I was first made aware of the concept while watching Will Burgess's awesome talk RedTeaming in the EDR Age, with Will crediting Casey Smith who presented the idea during a series of tweets. As with anything introduced to Cobalt Strike which has the chance to improve operational security, I wanted to dig into the concept further to see just how</description></item><item><title>ActiveBreach, powered by Ethereum Blockchain</title><link>https://blog.xpnsec.com/blockchainc2/</link><pubDate>Sat, 05 Jan 2019 17:00:06 +0000</pubDate><guid>https://blog.xpnsec.com/blockchainc2/</guid><description>I’m not actually sure when the abstraction of Blockchain started or when it became such a marketing buzzword, but with so many things claiming to be “Powered by The Blockchain”, I wanted to dig into the technology to understand if there was any benefit to be had by an aggressor.</description></item><item><title>RunDLL32 your .NET (AKA DLL exports from .NET)</title><link>https://blog.xpnsec.com/rundll32-your-dotnet/</link><pubDate>Mon, 05 Nov 2018 18:37:33 +0000</pubDate><guid>https://blog.xpnsec.com/rundll32-your-dotnet/</guid><description>In this post I wanted to look at a technique which is by no means new to .NET developers, but may prove useful to redteamers crafting their tools... exporting .NET static methods within a DLL... AKA using RunDLL32 to launch your .NET assembly.</description></item><item><title>Cisco AMP - Bypassing Self-Protection</title><link>https://blog.xpnsec.com/cisco-amp-bypassing-self-protection/</link><pubDate>Sat, 27 Oct 2018 21:48:34 +0000</pubDate><guid>https://blog.xpnsec.com/cisco-amp-bypassing-self-protection/</guid><description>Sometimes when you are in the middle of an engagement, you will come across a hurdle which requires a quick bit of research, coding, and a little bit of luck. This was the case with a recent engagement in which we came across Cisco AMP, an endpoint protection technology which provides analysis of processes, provides spawn chains, and exposed a bunch of the other goodies you have come to expect from EDR products, including our old friend…. self-protection. We’ve explored self-protection t</description></item><item><title>AppLocker CLM Bypass via COM</title><link>https://blog.xpnsec.com/constrained-language-mode-bypass/</link><pubDate>Mon, 01 Oct 2018 09:56:18 +0000</pubDate><guid>https://blog.xpnsec.com/constrained-language-mode-bypass/</guid><description>Constrained Language Mode is a method of restricting Powershell's access to functionality such as Add-Type, or many of the reflective methods which can be used to leverage the Powershell runtime as a launchbed for post-exploitation tooling. Despite what Microsoft may claim, this feature is very much being used as a security control, providing defenders with the ability to stop tools such as "Invoke-Mimikatz" from executing due to the heavy reliance on reflection techniques . As I was getting</description></item><item><title>macOS Research Outtakes - File Extensions</title><link>https://blog.xpnsec.com/macos-phishing-tricks/</link><pubDate>Sat, 22 Sep 2018 11:56:29 +0000</pubDate><guid>https://blog.xpnsec.com/macos-phishing-tricks/</guid><description>If you follow our research over on MDSec's blog, you will have seen a number of posts documenting macOS research we've recently completed. As RedTeamer's, we have a wealth of information available to us when it comes to attacking Windows endpoints, whether that be via a HTA, OLE, a macro office document or even simply binary hiding as a legitimate application, we are never short of options to gain access to a targets machine when phishing. The same unfortunately</description></item><item><title>Disabling MacOS SIP via a VirtualBox kext Vulnerability</title><link>https://blog.xpnsec.com/disabling-macos-sip-via-a-virtualbox-kext-vulnerability/</link><pubDate>Mon, 20 Aug 2018 12:01:20 +0000</pubDate><guid>https://blog.xpnsec.com/disabling-macos-sip-via-a-virtualbox-kext-vulnerability/</guid><description>As presented in our previous post exploring AV self-protection, the ability for an attacker to hide or protect software by leveraging protection features has become extremely interesting to me. With this in mind, I wanted to look at just how SIP bypasses were performed... enter VirtualBox.</description></item><item><title>Endpoint Security Self-Protection on MacOS</title><link>https://blog.xpnsec.com/macos-av-self-protection-methods/</link><pubDate>Tue, 14 Aug 2018 17:56:04 +0000</pubDate><guid>https://blog.xpnsec.com/macos-av-self-protection-methods/</guid><description>In this post we will analyse BitDefender on MacOS, looking at some of the self-protection methods hooking MacOS. At the end of the post, we will have a bit of fun and show just how we can leverage this technology to hide our malware during an engagement.</description></item><item><title>Escaping the Sandbox – Microsoft Office on MacOS</title><link>https://blog.xpnsec.com/escaping-the-sandbox-microsoft-office-on-macos/</link><pubDate>Wed, 08 Aug 2018 13:11:20 +0000</pubDate><guid>https://blog.xpnsec.com/escaping-the-sandbox-microsoft-office-on-macos/</guid><description>You’ve completed your recon, and found that your target is using MacOS… what next? With the increased popularity of MacOS in the enterprise, we are often finding that having phishing payloads targeting only Microsoft Windows endpoints is not enough during a typical engagement. With this in mind, I wanted to find an effective method of landing a stager on a MacOS system during a phishing campaign. In this walkthrough, I will show one possible way we can go about gaining a foothold by leveraging</description></item><item><title>Exploring PowerShell AMSI and Logging Evasion</title><link>https://blog.xpnsec.com/exploring-powershell-amsi-and-logging-evasion/</link><pubDate>Mon, 09 Jul 2018 00:19:41 +0000</pubDate><guid>https://blog.xpnsec.com/exploring-powershell-amsi-and-logging-evasion/</guid><description>By now, many of us know that during an engagement, AMSI (Antimalware Scripting Interface) can be used to trip up PowerShell scripts in an operators arsenal. Attempt to IEX Invoke-Mimikatz without taking care of AMSI, and it could be game over for your undetected campaign.</description></item><item><title>Exploiting CVE-2018-1038 - Total Meltdown</title><link>https://blog.xpnsec.com/total-meltdown-cve-2018-1038/</link><pubDate>Mon, 23 Apr 2018 06:16:32 +0000</pubDate><guid>https://blog.xpnsec.com/total-meltdown-cve-2018-1038/</guid><description>This week I had some free time to look into CVE-2018-1038 aka Total Meltdown. The aim was to create a quick exploit which could be used to elevate privileges during an assessment. I ended up delving into Windows memory management more than I had before.</description></item><item><title>Understanding and Evading Get-InjectedThread</title><link>https://blog.xpnsec.com/undersanding-and-evading-get-injectedthread/</link><pubDate>Mon, 09 Apr 2018 07:02:33 +0000</pubDate><guid>https://blog.xpnsec.com/undersanding-and-evading-get-injectedthread/</guid><description>One of the many areas of this field that I really enjoy is the "cat and mouse" game played between RedTeam and BlueTeam, each forcing the other to up their game. Often we see some awesome tools being released to help defenders detect malware or shellcode execution, and knowing just how these defensive capabilities function is important when performing a successful pentest or RedTeam engagement. Recently I came across the awesome post "Defenders Think in Graphs Too!", which can be found over on</description></item><item><title>Exploring Cobalt Strike's ExternalC2 framework</title><link>https://blog.xpnsec.com/exploring-cobalt-strikes-externalc2-framework/</link><pubDate>Fri, 30 Mar 2018 10:24:58 +0000</pubDate><guid>https://blog.xpnsec.com/exploring-cobalt-strikes-externalc2-framework/</guid><description>As many testers will know, achieving C2 communication can sometimes be a pain. Whether because of egress firewall rules or process restrictions, the simple days of reverse shells and reverse HTTP C2 channels are quickly coming to an end. OK, maybe I exaggerated that a bit, but it's certainly becoming harder. So, I wanted to look at some alternate routes to achieve C2 communication and with this, I came across Cobalt Strike’s ExternalC2 framework. ExternalC2 ExternalC2 is a specification/framew</description></item><item><title>Moving jobs and exploiting flash (CVE-2018-4878)</title><link>https://blog.xpnsec.com/cve-2018-4878/</link><pubDate>Thu, 15 Feb 2018 19:16:50 +0000</pubDate><guid>https://blog.xpnsec.com/cve-2018-4878/</guid><description>Recently I joined the MDSec team after seeing many of the cool things that they had contributed to the community, and to hopefully pick up some of their awesome skills. Shortly after joining I was pointed to a small research project, CVE-2018-4878, a Flash vulnerability classified as a "Use-After-Free". This vulnerability was being exploited in the wild, however due to the way in which the malware was encrypted, it was not possible to recover a live sample of the exploit. Basing research on so</description></item><item><title>Universal XSS via Evernote WebClipper</title><link>https://blog.xpnsec.com/evernote-webclipper-uxss/</link><pubDate>Thu, 18 Jan 2018 08:58:52 +0000</pubDate><guid>https://blog.xpnsec.com/evernote-webclipper-uxss/</guid><description>During an evening of bug hunting, I found a cool issue in Evernote's WebClipper tool. The result was a Universal XSS vulnerability, which we will explore in this post.</description></item><item><title>Exploiting Windows 10 Kernel Drivers - NULL Pointer Dereference</title><link>https://blog.xpnsec.com/hevd-null-pointer/</link><pubDate>Mon, 15 Jan 2018 07:00:00 +0000</pubDate><guid>https://blog.xpnsec.com/hevd-null-pointer/</guid><description>In this post, we will continue to explore driver exploitation, focusing on NULL pointer dereferences, and demonstrating how we can exploit this class of vulnerability on both Windows 7 x64 and Windows 10 x32.</description></item><item><title>Exploiting Windows 10 Kernel Drivers - Stack Overflow</title><link>https://blog.xpnsec.com/hevd-stack-overflow/</link><pubDate>Tue, 02 Jan 2018 12:40:32 +0000</pubDate><guid>https://blog.xpnsec.com/hevd-stack-overflow/</guid><description>Following on from my earlier post in which we walked through creating an exploit for the WARBIRD vulnerability, over the next few posts I'm going to be looking at Windows kernel exploitation. If you haven't had chance to read it, I'd recommend that you pause and give it a quick glance as some of this walkthrough will rely on concepts introduced previously. This post will start off by laying the groundwork for future posts, and walking through a simple stack overflow</description></item><item><title>Windows Anti-Debug techniques - OpenProcess filtering</title><link>https://blog.xpnsec.com/anti-debug-openprocess/</link><pubDate>Wed, 13 Dec 2017 12:27:08 +0000</pubDate><guid>https://blog.xpnsec.com/anti-debug-openprocess/</guid><description>This week I took a break from SYSTEM chasing to review some anti-debugging techniques. With quite a few Bug Bounty programs available relying on client-side applications, I thought I'd share one of the techniques used by numerous security products (and apparently game anti-cheat engines) to stop you from debugging core components, and just how we can go about bypassing this. Obviously it goes without saying, but the technique shown in this post is not a vulnerability, if an attacker has this le</description></item><item><title>Kernel Exploit Demo - Windows 10 privesc via WARBIRD</title><link>https://blog.xpnsec.com/windows-warbird-privesc/</link><pubDate>Mon, 27 Nov 2017 13:02:00 +0000</pubDate><guid>https://blog.xpnsec.com/windows-warbird-privesc/</guid><description>In this post I wanted to take a look at something which I touched on previously, and that is just how a Windows kernel based exploit achieves privilege escalation. Rather than take something like HackSys Extreme Vulnerable Windows Driver, I wanted to work on something a little bit different</description></item><item><title>Alternative methods of becoming SYSTEM</title><link>https://blog.xpnsec.com/becoming-system/</link><pubDate>Mon, 20 Nov 2017 11:02:26 +0000</pubDate><guid>https://blog.xpnsec.com/becoming-system/</guid><description>For many pentesters, Meterpreter's getsystem command has become the default method of gaining SYSTEM account privileges, but have you ever have wondered just how this works behind the scenes? In this post I will show the details of how this technique works, and explore a couple of methods which are not quite as popular, but may help evade detection on those tricky redteam engagements. Meterpreter's "getsystem" Most of you will have used the getsystem module in Meterpreter before. For those tha</description></item><item><title>Kerberos AD Attacks - More Roasting with AS-REP</title><link>https://blog.xpnsec.com/kerberos-attacks-part-2/</link><pubDate>Wed, 08 Nov 2017 12:30:00 +0000</pubDate><guid>https://blog.xpnsec.com/kerberos-attacks-part-2/</guid><description>In this post we will be exploring another "roasting" method which involves exploiting a weak account configuration setting in Active Directory.. AS-REP Roasting.</description></item><item><title>Defcon 25 in Review</title><link>https://blog.xpnsec.com/defcon-25/</link><pubDate>Sat, 04 Nov 2017 08:00:00 +0000</pubDate><guid>https://blog.xpnsec.com/defcon-25/</guid><description>This year I attended Defcon for the second time. I live in the UK, so making it out to the US for this awesome conference is something that I look forward to throughout the year. As part of my day job I'm a penetration tester, and I actually found myself in Santa Clara the week before Defcon on an assessment. Due to some unique circumstances, I took what I think must be a record breaking detour back to Defcon. After checking out the local famous garages and technology spots, I was on a flight b</description></item><item><title>Setting Service Principal Names To Roast Accounts</title><link>https://blog.xpnsec.com/setting-service-principal-names-to-roast-accounts/</link><pubDate>Sat, 04 Nov 2017 01:38:53 +0000</pubDate><guid>https://blog.xpnsec.com/setting-service-principal-names-to-roast-accounts/</guid><description>As a continuation of our previous post, we wanted to discuss another technique that can help during an red team engagement where the intention is to usually stay under the radar when compromising high value accounts.</description></item><item><title>Using machine account credentials during an engagement</title><link>https://blog.xpnsec.com/using-machine-accounts-during-an-engagement/</link><pubDate>Mon, 30 Oct 2017 11:53:50 +0000</pubDate><guid>https://blog.xpnsec.com/using-machine-accounts-during-an-engagement/</guid><description>Of the many advancements in red teaming over the last 12 months, the development of BloodHound has provided a monumental step forward and is quickly becoming an essential tool in the arsenal of an attacker.</description></item><item><title>Kerberos AD Attacks - Kerberoasting</title><link>https://blog.xpnsec.com/kerberos-attacks-part-1/</link><pubDate>Sat, 30 Sep 2017 22:28:08 +0000</pubDate><guid>https://blog.xpnsec.com/kerberos-attacks-part-1/</guid><description>Recently I've been trying to make sure that my redteam knowledge is up to date, exploring many of the advancements in Active Directory Kerberos attacks... and there have been quite a few! I finally found some free time this week to roll up my sleeves and dig into the internals of some of these attacks, and hopefully document them for other people to learn. This post is the first in a series aimed at explaining what is happening under the hood when you execute your favourite Powerview or Mimikat</description></item><item><title>ExplodingCan - A vulnerability review</title><link>https://blog.xpnsec.com/explodingcan-a-vulnerability-review/</link><pubDate>Mon, 18 Sep 2017 14:16:57 +0000</pubDate><guid>https://blog.xpnsec.com/explodingcan-a-vulnerability-review/</guid><description>A few months ago, my colleagues over at Secarma released a review of ExplodingCan, one of the many exploits released as part of the ShadowBrokers dump. At the time I was asked to complete a review of the vulnerability, specifically how this affected a vulnerable server and if anything could be done to protect users.</description></item><item><title>Analysis of APT28 hospitality malware (Part 2)</title><link>https://blog.xpnsec.com/apt28-hospitality-malware-part-2/</link><pubDate>Sun, 13 Aug 2017 20:19:00 +0000</pubDate><guid>https://blog.xpnsec.com/apt28-hospitality-malware-part-2/</guid><description>In the first part of this malware review, we looked at the VBA code used by APT28 to drop a DLL onto the victims' machine as part of their recently highlighted hospitality campaign. In this post, we will look at the dropped file, and understand just what it does, and how we can analyse it using IDA Pro. So we know from the first post that we have a DLL, which is</description></item><item><title>Analysis of APT28 hospitality malware</title><link>https://blog.xpnsec.com/apt28-hospitality-malware/</link><pubDate>Sat, 12 Aug 2017 14:48:55 +0000</pubDate><guid>https://blog.xpnsec.com/apt28-hospitality-malware/</guid><description>This week, FireEye published a writeup of yet another APT28 campaign, this time targeting the hospitality sector. I'm always interested to see the latest APT group techniques, so I decided to review the malware to see how the dropper worked</description></item><item><title>How GitHub login detection banner works</title><link>https://blog.xpnsec.com/how-github-login-detection-works/</link><pubDate>Fri, 11 Aug 2017 16:11:08 +0000</pubDate><guid>https://blog.xpnsec.com/how-github-login-detection-works/</guid><description>Sometimes I come across things non-security related that intrigue me, albeit mostly I'm thinking how I can use it to exploit a service, but still... One such piece of functionality caught my interest, a banner displayed at the top of GitHub. I was thinking of the different ways that this type of functionality could be achieved. We have seen similar methods of detection exploited in the past to leak out information, although much more targeted at cross-origin detection (such as Social Media F</description></item><item><title>Industroyer C2 Communication</title><link>https://blog.xpnsec.com/industroyer-c2-protocol/</link><pubDate>Tue, 04 Jul 2017 20:22:30 +0000</pubDate><guid>https://blog.xpnsec.com/industroyer-c2-protocol/</guid><description>As part of my day job, I work for Secarma (previously known as Pentest Limited) as a Senior Penetration Tester. During engagements, the question of malware threats is increasingly raised, in part due to media focus on APT groups such as APT28, and malware campaigns such as WannaCry. While looking into another malware variant recently uncovered by ESET, Industroyer, I started reviewing the protocol used to communicate with the backdoor component of the malware. Details of the research have bee</description></item><item><title>Using Hopper scripting to analyse MacRansom</title><link>https://blog.xpnsec.com/hopper-scripting-macransom/</link><pubDate>Thu, 15 Jun 2017 22:18:17 +0000</pubDate><guid>https://blog.xpnsec.com/hopper-scripting-macransom/</guid><description>This week, Objective-See published a walkthrough of the recently released "Malware as a Service" family, MacRansom, originally identified by FortiNet. Patrick from Objective-See does a brilliant fly-by of the malware using LLDB, and presents some nice "anti anti-analysis" tricks. If you are interested in the internals of the malware, I'd recommend that you take a</description></item><item><title>Reviewing the APT32 phishing malware</title><link>https://blog.xpnsec.com/apt32-phishing-malware/</link><pubDate>Sat, 20 May 2017 21:50:16 +0000</pubDate><guid>https://blog.xpnsec.com/apt32-phishing-malware/</guid><description>This week, FireEye released an awesome review into APT32 (aka OceanLotus). The full writeup of their analysis can be found on FireEye's site here, and is certainly worth a read if you are interested in the evolving world of APT and attribution. One of the things I found interesting about this group was their use of "off the shelf" open source tools and techniques, often associated with commercial red-team engagem</description></item><item><title>Exploiting with pwndbg - Solving PlaidCTF 2016 SmartStove</title><link>https://blog.xpnsec.com/pwndbg/</link><pubDate>Tue, 02 May 2017 08:28:16 +0000</pubDate><guid>https://blog.xpnsec.com/pwndbg/</guid><description>This bank holiday weekend I spent a bit of time updating my docker containers (I know, rock-n-roll!). One of the tools I've been hearing good things about is pwndbg, an open source plugin for GDB which aims to help with exploit development. I've always been a fan of peda, which provides similar functionality, but seeing the integration that pwndbg had with radare2, I couldn't help but give it a shot. To install the tool, I used the provided installation instructions</description></item><item><title>Revisiting PlaidCTF - bigpicture</title><link>https://blog.xpnsec.com/revisiting-plaidctf-bigpicture/</link><pubDate>Tue, 25 Apr 2017 23:40:29 +0000</pubDate><guid>https://blog.xpnsec.com/revisiting-plaidctf-bigpicture/</guid><description>During the PlaidCTF challenge, there were a couple of binaries which, whilst I had a general idea of how the vulnerability worked, I couldn't complete in time to grab a flag. This has been bugging me since the end of the CTF, so I wanted to revisit one such challenge and see what I was missing. That challenge was "bigpicture". To begin with, you are given a simple description</description></item><item><title>PlaidCTF - no_mo_flo writeup</title><link>https://blog.xpnsec.com/plaidctf-no_mo_flo-writeup/</link><pubDate>Mon, 24 Apr 2017 23:19:53 +0000</pubDate><guid>https://blog.xpnsec.com/plaidctf-no_mo_flo-writeup/</guid><description>This weekend I joined team NeverTry on PlaidCTF. One of the interesting challenges that I attempted was the "no_mo_flo" reverse engineering exercise. The description provided was simple... Can you go with the flow? To begin with, we load the challenge in IDA Pro. After some parsing, we see the first step is to read 0x20 bytes from STDIN</description></item><item><title>Linux ptrace introduction AKA injecting into sshd for fun</title><link>https://blog.xpnsec.com/linux-process-injection-aka-injecting-into-sshd-for-fun/</link><pubDate>Wed, 19 Apr 2017 09:27:50 +0000</pubDate><guid>https://blog.xpnsec.com/linux-process-injection-aka-injecting-into-sshd-for-fun/</guid><description>If there is one thing I've come to appreciate over this past few weeks, it's just how much support you are provided from the Win32 API. That being said, I wanted to tackle some Linux process injection, with the aim of loading a shared object into another process address space without having to resort to LD_PRELOAD, or stopping the process. The goal I set myself was quite simple, could I recover plain text credentials from the sshd process using ptrace. Granted, this is a bit of an arbitrary goa</description></item><item><title>New Blog and the Technology that powers it</title><link>https://blog.xpnsec.com/blog-tech/</link><pubDate>Thu, 06 Apr 2017 13:58:17 +0000</pubDate><guid>https://blog.xpnsec.com/blog-tech/</guid><description>As you may have noticed, I've migrated my blog from Tumblr to a shiny Ghost powered engine. While it does feel like I'm leaving the social media buzzword bingo revolution behind, editing on Tumblr wasn't exactly made with lengthy InfoSec posts in mind. Of course, moving to Ghost in my case means provisioning and managing a new server, so I wanted to take some time to document the architecture of my solution incase anyone else is looking to make a similar change in the future. Hosting My hosti</description></item><item><title>BSidesSF CTF - DNSCap Walkthrough</title><link>https://blog.xpnsec.com/bsidessf-dnscap/</link><pubDate>Mon, 06 Mar 2017 01:24:18 +0000</pubDate><guid>https://blog.xpnsec.com/bsidessf-dnscap/</guid><description>Of all the BSidesSF CTF challenges, I think this one has to be my favourite. Combining a mix of packet capture analysis, scripting, frustration, and trying to beat the clock. The brief provided by the challenge was quite straight forward</description></item><item><title>BSidesSF CTF - Steel Mountain: Sensors Walkthrough</title><link>https://blog.xpnsec.com/bsidessf-sensors/</link><pubDate>Sun, 05 Mar 2017 19:06:50 +0000</pubDate><guid>https://blog.xpnsec.com/bsidessf-sensors/</guid><description>Continuing my write-up series from BSides SF's CTF, today I'll be looking at a "pwn" challenge, Steel Mountain - Sensors. The challenge starts with a link, and a cryptic comment</description></item><item><title>BSidesSF CTF: b-64-b-tuff Walkthrough</title><link>https://blog.xpnsec.com/bsidessf-b-64-b-tuff/</link><pubDate>Sun, 05 Mar 2017 19:06:13 +0000</pubDate><guid>https://blog.xpnsec.com/bsidessf-b-64-b-tuff/</guid><description>This week I was part of team "NeverTry" who competed in the BSidesSF online capture the flag. As far as CTF's go, this was a fun one, taking place over 2 days there were a range of cool puzzles and flags to find. Over a series of upcoming posts I'll be running through the solutions for a number of my favourite challenges, starting with b-64-b-tuff. This challenge started with a simple application which receives binary shellcode over the network, and executes th</description></item><item><title>ROP Primer - Walkthrough of Level 2</title><link>https://blog.xpnsec.com/rop-primer-level-2/</link><pubDate>Sun, 05 Mar 2017 19:05:32 +0000</pubDate><guid>https://blog.xpnsec.com/rop-primer-level-2/</guid><description>In the final post in this series, we'll be looking at Level 2, the last level of ROP Primer from VulnHub. This level gives a very simple program, similar to the first challenge that we faced in Level 0. The source of the application is as follows</description></item><item><title>ROP Primer - Walkthrough of Level 1</title><link>https://blog.xpnsec.com/rop-primer-level-1/</link><pubDate>Sun, 05 Mar 2017 19:04:58 +0000</pubDate><guid>https://blog.xpnsec.com/rop-primer-level-1/</guid><description>Continuing from the previous post which shows a solution for Level 0, we are going to look at Level 1 of ROP Primer from VulnHub. Level 1 is a server application, which suffers from a typical buffer overflow. Reviewing the application source provided by the challenge, we can see that the overflow vector is within the following code</description></item><item><title>ROP Primer - Walkthrough of Level 0</title><link>https://blog.xpnsec.com/rop-primer-level-0/</link><pubDate>Sun, 05 Mar 2017 19:04:20 +0000</pubDate><guid>https://blog.xpnsec.com/rop-primer-level-0/</guid><description>I recently found Vulnhub ROP Primer, which is a brilliant playground for refreshing your Linux ROP skills. To try and share some of the techniques I used to solve these challenges, I'm completing a series of writeups detailing the steps to solve each level. In typical Vulnhub style we start with a virtual machine which runs a number of services alongside a HTTP server documenting the 3 levels of difficulty. This post will be looking at Level 0</description></item><item><title>Radare2 - Using Emulation To Unpack Metasploit Encoders</title><link>https://blog.xpnsec.com/radare2-using-emulation-to-unpack-metasploit-encoders/</link><pubDate>Sun, 05 Mar 2017 19:03:31 +0000</pubDate><guid>https://blog.xpnsec.com/radare2-using-emulation-to-unpack-metasploit-encoders/</guid><description>Radare2 is an open source reverse engineering framework, and is quickly becoming one of my favourite tools when picking apart malware or looking at CTF binaries. I was recently introduced to Radare’s ESIL (Evaluable Strings Intermediate Language), which is a way of representing instructions in a forth like language, and allows emulation of machine instructions in Radare’s ESIL VM. To help understand this functionality, lets look at some examples from the radare2 book</description></item><item><title>Windows Server 2016 / Docker Privilege Escalation</title><link>https://blog.xpnsec.com/windows-server-2016-docker-privilege-escalation/</link><pubDate>Sun, 05 Mar 2017 19:02:16 +0000</pubDate><guid>https://blog.xpnsec.com/windows-server-2016-docker-privilege-escalation/</guid><description>After catching Microsoft's talk at DockerCon discussing the recent addition of Docker container support in Windows Server 2016, I wanted to play around with the technology with the aim of understanding how this could be leveraged during a security assessment. Before starting, I first had to configure Windows Server to support Docker containers. This was pretty painless using the following steps</description></item><item><title>Kentico CMS (&lt; 9.0.42) SQLi</title><link>https://blog.xpnsec.com/kentico-cms-9-0-42-sqli/</link><pubDate>Sun, 05 Mar 2017 19:01:10 +0000</pubDate><guid>https://blog.xpnsec.com/kentico-cms-9-0-42-sqli/</guid><description>Kentico CMS is a web content management system for building websites, e-commerce stores and numerous other web applications in ASP.NET. During a review of the CMS in a lab environment, I came across a SQL injection vulnerability which was interesting due to the complicated regex check which is used to try and prevent this kind of exploit. Kentico CMS supports the ability for users to query a website via a REST based API. Whilst varying levels of authorisation are used to restrict access, a num</description></item><item><title>Offensive Forensics - Recovering Files</title><link>https://blog.xpnsec.com/offensive-forensics/</link><pubDate>Sun, 05 Mar 2017 18:57:26 +0000</pubDate><guid>https://blog.xpnsec.com/offensive-forensics/</guid><description>At the moment, I've been looking at post exploitation methods, weather that is gaining persistance, extracting hashes, or finding additional pivot points. One area that I'm quickly becoming interested in is applying basic forensics techniques to help recover data during an assessment. One framework that can help with this, is PowerForensics. This framework comes with a number of interesting options, but the one which is useful for recovered deleted</description></item><item><title>Github Desktop - DOM XSS</title><link>https://blog.xpnsec.com/github-desktop-dom-xss/</link><pubDate>Sun, 05 Mar 2017 18:56:43 +0000</pubDate><guid>https://blog.xpnsec.com/github-desktop-dom-xss/</guid><description>I’ve always enjoyed “unusual” vulnerabilities, either bugs that you never knew were exploitable, or just funny quirks which lead to a vulnerability. My recent finding within the Github Desktop for OSX ticked a few of those boxes, allowing me to trigger cross-site scripting in a desktop application. The vulnerability is present due to the use of the Chromium Embedded Framework, which is used by the comparison graph you see at the top of the windo</description></item><item><title>Extracting SQL Server Hashes From master.mdf</title><link>https://blog.xpnsec.com/extracting-master-mdf-hashes/</link><pubDate>Sun, 05 Mar 2017 18:54:23 +0000</pubDate><guid>https://blog.xpnsec.com/extracting-master-mdf-hashes/</guid><description>During a number of engagements, I have found myself in a position in which I have held administrative access to a server running a local instance of Microsoft SQL Server, but had not held credentials to access the service. For seasoned penetration testers out there, you will know that there are multiple ways to gain access to a SQL Server once you have access to the local server, for example running SQLQuery as the SYSTEM user which often runs under the SysAdmin permission, or injecting into th</description></item><item><title>Linux USBIP overflow (CVE-2016-3955)</title><link>https://blog.xpnsec.com/cve-2016-3955/</link><pubDate>Sun, 05 Mar 2017 18:53:41 +0000</pubDate><guid>https://blog.xpnsec.com/cve-2016-3955/</guid><description>Recently I was forwarded a link to a patch within the Linux kernel which mitigates an overflow vulnerability within the USBIP functionality. For those that have never encountered USBIP, this is a protocol offered to allow remote clients to access USB devices plugged into a host machine. Reviewing the patch, the issue was immediately visible as being a heap overflow vulnerability, exploitable due to a user controlled size value being trusted without validation. So first let's look at the patch</description></item><item><title>GitHub Desktop - RCE</title><link>https://blog.xpnsec.com/github-desktop-rce/</link><pubDate>Sun, 05 Mar 2017 18:45:14 +0000</pubDate><guid>https://blog.xpnsec.com/github-desktop-rce/</guid><description>Recently GitHub disclosed a vulnerability which I reported within the GitHub for Windows client. This report can be found here. The aim of this post is to give a quick rundown of how the issue was discovered, and to introduce this type of vulnerability for those that may not have seen it before. The GitHub for Windows client provides users with an easy way to manage their GitHub repo’s, from pushing to GitHub for the first time, to creating pull</description></item><item><title>Bettercap - Capturing NTLM Hashes</title><link>https://blog.xpnsec.com/bettercap-capturing-ntlm/</link><pubDate>Sun, 05 Mar 2017 18:44:22 +0000</pubDate><guid>https://blog.xpnsec.com/bettercap-capturing-ntlm/</guid><description>As many of you who follow me on twitter will know, I'm a big fan of the Bettercap project. Created by @EvilSocket, this tool is a reimagining of the historic Ettercap project, bringing it up to date, it's an invaluable tool for the penetration testing arsenal. One of the many modules offered by the project is the HTTP Proxy module, which allows a man-in-the-middle to transparently proxy and modify HTTP traffic being returned to a user. While the possibilities ar</description></item><item><title>Xbox One Controller Hacking</title><link>https://blog.xpnsec.com/xbox-one-controller/</link><pubDate>Sun, 05 Mar 2017 18:42:57 +0000</pubDate><guid>https://blog.xpnsec.com/xbox-one-controller/</guid><description>So today I had a bit of free time, and decided to experiment with the LibUSB framework on a Raspberry Pi I had lying around. After a bit of reading, and reviewing the excellent documentation provided by the Xbox hacking community, I managed to get a simple C program running which demoed interrupt transfers for both activating the controller rumble feature, and receiving button presses. For those interested, the code for the demo application can be found here</description></item><item><title>SQL Server Authentication With Metasploit and MITM</title><link>https://blog.xpnsec.com/sql-server-auth-mitm/</link><pubDate>Sun, 05 Mar 2017 18:38:27 +0000</pubDate><guid>https://blog.xpnsec.com/sql-server-auth-mitm/</guid><description>While exploring the depths of Metasploit capture modules, I came across auxiliary/server/capture/mssql which can be found here. The module can be used to capture Microsoft SQL Server logon credentials if a user or client authenticates with the module. What caught my attention is just how effective this module can be in retrieving plain text credentials. First a bit of background on SQL server authentication. Usually authenticat</description></item><item><title>Foomatic-RIP (CVE-2015-8560)</title><link>https://blog.xpnsec.com/cve-2015-8560/</link><pubDate>Sun, 05 Mar 2017 18:34:49 +0000</pubDate><guid>https://blog.xpnsec.com/cve-2015-8560/</guid><description>Just a quick writeup today, recently I uncovered an issue in the Foomatic-RIP package. The bug can be found within the "filter/foomatic-rip/util.c" source and is due to the whitelist used within the following line</description></item><item><title>MS15-099 - Sharepoint XSS</title><link>https://blog.xpnsec.com/ms15-099/</link><pubDate>Sun, 05 Mar 2017 18:30:00 +0000</pubDate><guid>https://blog.xpnsec.com/ms15-099/</guid><description>Recently during a review of Sharepoint, I came across a vulnerability discovered by the Fortinet team and published on their blog. The post contained information on what a successful exploit would look like, but provided no final exploit for verification or testing. After a bit of review, I found the following POC code which, when triggered, shows a simple alert dialog box</description></item><item><title>From CSV to Meterpreter</title><link>https://blog.xpnsec.com/from-csv-to-meterpreter/</link><pubDate>Thu, 05 Nov 2015 18:20:00 +0000</pubDate><guid>https://blog.xpnsec.com/from-csv-to-meterpreter/</guid><description>As many of you have probably seen, last year Context published research into spreadsheet applications such as Excel which render CSV files (and their embedded formula) when opened. If you haven't, I suggest stopping and reading http://www.contextis.com/resources/blog/comma-separated-vulnerabilities/ Many web applications provide a user with an option to export data to a CSV file format, and when the data can be influenced by an attacker (registration names, analytics etc), you are facing a pot</description></item><item><title>About Me</title><link>https://blog.xpnsec.com/about/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://blog.xpnsec.com/about/</guid><description/></item></channel></rss>