<?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 Ryan Severns on Medium]]></title>
        <description><![CDATA[Stories by Ryan Severns on Medium]]></description>
        <link>https://medium.com/@severns?source=rss-1dd66a1f2f93------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*tvgAArwdZArxdYcCkRpmGg.jpeg</url>
            <title>Stories by Ryan Severns on Medium</title>
            <link>https://medium.com/@severns?source=rss-1dd66a1f2f93------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 09:06:19 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@severns/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[StackHawk’s Free Developer Plan: Application Security Testing for All]]></title>
            <link>https://severns.medium.com/stackhawks-free-developer-plan-application-security-testing-for-all-f3dc177d4b29?source=rss-1dd66a1f2f93------2</link>
            <guid isPermaLink="false">https://medium.com/p/f3dc177d4b29</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[application-security]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Ryan Severns]]></dc:creator>
            <pubDate>Tue, 08 Dec 2020 05:30:16 GMT</pubDate>
            <atom:updated>2020-12-08T13:51:06.291Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/696/0*qiFs1ZncMpAHRuql.png" /></figure><p>Today we are excited to announce the launch of StackHawk’s free Developer Plan. With this launch, engineering teams or individual developers can take ownership of security in the development and delivery of their applications. Read on to learn a bit more about why we are so excited to launch this, or jump right in to <a href="https://auth.stackhawk.com/signup">sign up for a free account</a>.</p><h3>Application Security’s New Paradigm</h3><p>It is no secret that the speed of application delivery has rapidly accelerated over the past decade. Most companies are pushing to production several times per week, or even multiple times per day. Originally, security struggled to keep up, with the dated models of quarterly penetration tests or manual scans by security teams clearly <a href="https://www.stackhawk.com/blog/application-security-is-broken/">no longer cutting it</a>.</p><p>These legacy models were predicated on finding vulnerabilities in production, often awhile after code had been deployed. This is at best, inefficient, and at worst a security issue. Once a vulnerability was found, it then had to navigate internal silos to actually get a fix released.</p><p>Modern engineering teams, however, have not only accelerated delivery speed, but have also improved security in the process. Here is how.</p><h4>Find Vulnerabilities with CI/CD Automation</h4><p>Companies using modern approaches check for security vulnerabilities on every pull request (or even every commit) in the same way that they run unit tests and integration tests. With automated testing in CI/CD, developers can catch vulnerabilities early in the software development lifecycle, and fix issues while they are still in the context of the code.</p><p>After an initial triage of any existing security bugs, application security tooling should at least be configured to break the build if any new high criticality vulnerabilities are identified. This doesn’t mean that every vulnerability should prevent a deploy to production, but that deploy should be done eyes wide open to the risk it presents.</p><h4>Triage and Initial Risk Decisions Live with Developers</h4><p>When a vulnerability is found, the developer(s) who were recently working on the application are best equipped to review the finding and make risk-based decisions. Should this block the deploy to production? Can this be added to a backlog and addressed later? Is this low enough risk that it isn’t worth fixing?</p><p>The individuals who are intimately involved in creating the application are best equipped as the first-line of defense for these decisions. Internal security teams are undoubtedly called upon for clarification and support (…and are often reviewing historical decisions as well), but modern teams are empowering developers to make these triage decisions themselves.</p><h4>Fast Developer Fixes</h4><p>When a security bug requires a fix, the responsibility for the fix squarely lives with the developer who introduced the vulnerability in modern teams. This individual is in the codebase, familiar with the context of the recent vulnerability addition. Not only are they best equipped to implement the fix, but by democratizing this responsibility across the team, no person or team bears the burden of interrupt driven work.</p><h3>Taking Ownership of Application Security</h3><p>Ever since we embarked upon building StackHawk, we have been laser focused on building a tool for developers. The market is rife with security tools built for the CISO that no developer wants to use, and these tools typically start at six-figure contracts. StackHawk is different, and we are excited to equip engineers to own the security of their application. This shows up in our product, and with our new free Developer Plan, it also shows up in our pricing.</p><p>Now individuals or teams can start running application security tests against their first application for free. There is no longer an excuse not to be looking at the security of your application.</p><p>Getting started with StackHawk is easy, with most developers completing their first security test in under 20 minutes. You can get the full details in <a href="https://docs.stackhawk.com/">our docs</a>, but in short it is as simple as building a yaml config, pointing the scanner at your application, and taking a look at the results. <br><a href="https://auth.stackhawk.com/signup">Sign up</a> for a free account and give it a try today!</p><p><em>Originally published at </em><a href="https://www.stackhawk.com/blog/free-plan-announcement/"><em>https://www.stackhawk.com</em></a><em> on December 8, 2020.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f3dc177d4b29" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Doesn’t Your CI Pipeline Have Security Bug Testing?]]></title>
            <link>https://medium.com/stackhawk/why-doesnt-your-ci-pipeline-have-security-bug-testing-c501314c2d77?source=rss-1dd66a1f2f93------2</link>
            <guid isPermaLink="false">https://medium.com/p/c501314c2d77</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[continuous-integration]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Ryan Severns]]></dc:creator>
            <pubDate>Tue, 26 May 2020 22:10:20 GMT</pubDate>
            <atom:updated>2020-05-27T03:47:56.649Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*fe8CC3-_qyXQ0LSN.jpg" /></figure><h3>Software Engineering has Changed with CI/CD.</h3><p>Continuous integration and continuous delivery has changed software engineering. Teams are shipping small change sets often and automation has made the life of an engineer a lot simpler. Automation throughout the CI/CD pipeline has touched nearly everything, with integrations and tooling for linting, unit testing, integration testing, deployment, and more.</p><blockquote><strong><em>Application security, however, has been left behind.</em></strong></blockquote><p>While there are a few exceptions, most application security products are dated technology built for an era before DevOps, CI/CD, and modern software engineering products. These products are also built for the security teams instead of the developers who are close to the code. This is obviously a problem.</p><h3>Application Security: Super Important and Super Broken</h3><p>It goes without saying that building secure applications is imperative for any engineering team today. Without baking security into your application, your company opens itself up to leaking sensitive data, degrading user experience, or allowing account takeover. As most companies in the world shift to be software-first, application security will only become increasingly important.</p><p>While clearly vitally important, current <a href="https://www.stackhawk.com/blog/application-security-is-broken/">AppSec models are broken</a>. <strong>The traditional approaches to application security prioritize training over tooling and finding over fixing. </strong>InfoSec teams are holding onto dated practices of periodic, point in time scans of production. Vulnerabilities are kicked back to the engineering team in long lists or large Jira backlogs, which then sit deprioritized over feature development. If the work is pulled into a sprint, it requires the developer to jump back into code that they likely haven’t touched for weeks or months.</p><p>Adding to this problem is the fact that the majority of the security products on the market are legacy enterprise tools. They are built for a different era of software development and continue to serve the technology dinosaurs that have yet to adopt modern DevOps workflow. Features are built for security teams and favor long approval chains and reports rather than enabling the developers who will fix the security bugs to get to the job of fixing found issues.</p><blockquote><strong><em>A shift is needed in both culture, workflows, and tooling.</em></strong></blockquote><p>There is a better way 👇.</p><h3>The AppSec Future: Application Security Tests in Every CI/CD Build</h3><p>While shifting security left has been a trade show booth tagline for years now, we are at the advent of that truly becoming a reality. In the same way that many engineers now define and monitor their own infrastructure, developers are learning that they can take security testing into their own hands. Proper tooling and pipeline automation will drive this shift.</p><p>So what does application security tests in every build look like?</p><p>You’ll want to instrument two types of security testing, commonly known as SAST and DAST. SAST (Static Analysis Security Testing) scans your code base and its associated dependencies for known vulnerabilities. DAST (Dynamic Analysis Security Testing) runs tests against a running version of your application to find externally exploitable security bugs. Both are important, and both can be added to your CI builds.</p><p>Then, on every merge, your pipeline can run security testing. When a developer adds a security bug, they will be alerted and can quickly fix. Tests should be instrumented later in the pipeline as well to ensure that new bugs are not introduced — think of it as security integration testing. When a bug is found, fixes can be tested locally before kicking off a new build.</p><h3>A New Breed of AppSec Tooling</h3><p>To add application security testing to the CI/CD pipeline, the right tools are needed. As mentioned, the traditional security products on the market are heavy on enterprise sales and light on features for the modern dev shop. Luckily, new tools are hitting the market that are built for developer-first security.</p><p>As you look at potential tools, here are a few things to consider:</p><ul><li><strong>How is The App Scanned:</strong> Are your DAST scans scheduled against a production environment, or does the tool assume ephemeral environments and pipeline runs? Does the SAST tool want you to zip up your code and ship it off to them, or does it integrate deeply into your source code repository?</li><li><strong>Support for Modern Applications:</strong> Does the tool support modern development paradigms, such as single page applications, GraphQL, or JAM stack applications? Can it work with OpenAPI spec, or does it simply rely on an HTML spider? Does it simply scan publicly available sites, or can it work with multiple forms of authentication?</li><li><strong>Noise Management: </strong>Traditional security tools are noisy with false positives and assume that fixing *all* findings is a priority over all else. Does the tool support quieting of noise to ensure that your workflows are not blown up by the addition of your security tool?</li></ul><h3>Getting Started</h3><p>Adding application security tests to your CI/CD pipeline can feel like a daunting task, but it is actually easy to get started. Here’s how:</p><ul><li><strong>Pick Your Tools: </strong>Select SAST and DAST tools that you can easily try out and add to your pipeline. Make sure they hit on the new breed criteria above. (Hint: if they don’t let you test without first seeing a demo, they probably aren’t built for developers). I’m a little biased, but StackHawk is really the only DAST tool built for developers. And here at StackHawk, we are big fans of <a href="http://snyk.io/">Snyk</a> for SAST.</li><li><strong>Instrument in Pipeline: </strong>After configuring your tooling, add it to your CI/CD pipeline. We recommend starting with non-blocking runs at first while you triage any existing backlog of security issues. Now every build will include application security tests. For more examples of configuring pipeline instrumentation with StackHawk, check out our <a href="https://docs.stackhawk.com/continuous-integration/">docs</a> or this blog on instrumenting <a href="https://www.stackhawk.com/blog/add-appsec-to-circle-ci-pipeline/">StackHawk with CircleCI</a>.</li><li><strong>Roll Out Across Engineering: </strong>Application security works best when distributed, with engineers fixing their own security bugs as they build software. This happens with a cultural shift first, but a cultural shift happens a lot easier when the right tooling is in place. One thing that helps drive the culture shift is visibility. At StackHawk, we are big fans of pushing the StackHawk results from a pipeline run into <a href="https://www.stackhawk.com/blog/slack-integration-announcement/">Slack</a>. Another thing that helps the culture shift is putting the fix of new issues in the hands of each engineer, while managing the fix of the existing backlog through a different workstream.</li></ul><p>At StackHawk, we’re obviously super passionate about this topic. If you want to talk shop, get technical support, or learn more about how we can help here, shoot us a note at <a href="/service/mailto:hello@stackhawk.com">hello@stackhawk.com</a>.</p><p><em>Originally published at </em><a href="https://www.stackhawk.com/blog/ci-pipeline-security-bug-testing/"><em>https://www.stackhawk.com</em></a><em> on May 26, 2020.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c501314c2d77" width="1" height="1" alt=""><hr><p><a href="https://medium.com/stackhawk/why-doesnt-your-ci-pipeline-have-security-bug-testing-c501314c2d77">Why Doesn’t Your CI Pipeline Have Security Bug Testing?</a> was originally published in <a href="https://medium.com/stackhawk">StackHawk</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Application Security is Broken.]]></title>
            <link>https://medium.com/stackhawk/application-security-is-broken-d90fcea2d130?source=rss-1dd66a1f2f93------2</link>
            <guid isPermaLink="false">https://medium.com/p/d90fcea2d130</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[application-security]]></category>
            <dc:creator><![CDATA[Ryan Severns]]></dc:creator>
            <pubDate>Wed, 20 May 2020 08:23:00 GMT</pubDate>
            <atom:updated>2020-05-20T20:48:13.411Z</atom:updated>
            <content:encoded><![CDATA[<h4>Here is How We Intend to Fix It.</h4><p>Application security as we know it today is broken.</p><p>You commit your code and push features into production, only to get a high priority Jira ticket from security months later with little context. At this point, a security bug has been in production for months and you are pulled into an inefficient fix process.</p><p>There is a better way.</p><h3>tl;dr</h3><ul><li><strong>Modern AppSec is Broken.</strong> Agile, Cloud, DevOps, CI/CD, and open source have changed everything for engineers, but security processes struggle to keep up.</li><li><strong>AppSec’s Future is in Engineering Teams. </strong>Traditional IT Operations was replaced by DevOps; shouldn’t engineering own the security of the code they write?</li><li><strong>A New Breed of Security Tools are Coming. </strong>We are part of a small but powerful group of security tools that are built for the developers who do the actual fixing of security bugs.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WOQLQCJNpN97KHIubY9N9A.png" /></figure><h3>Application Security is Broken</h3><p>Applications are being pushed into the world faster than ever before. Cloud deployments, DevOps teams, and CI/CD have enabled engineering teams to produce high quality software with incredible efficiency. As these applications are pushed to production, often multiple times per week or day, the current security model can’t keep up.</p><p>Below are some of the ways that AppSec is no longer working for modern software teams:</p><ul><li><strong>Doesn’t Match Modern Workflows. </strong>Development has shifted to continuous delivery, with endless tools to support you in your work. You deploy software quickly and count on test suites to catch bugs. Your application security tools, however, are built for a waterfall era and exist in isolation from the rest of your workflow.</li><li><strong>Not Built for Automation.</strong> Security bug testing should be automated throughout the delivery pipeline, starting as close to local dev as possible. Solutions that center on testing once an app hits production just don’t cut it in this day and age.</li><li><strong>Finding &gt; Fixing.</strong> Existing application security tools (and, in some cases, teams) engage in a contest of finding the most things and you get an ever increasing backlog. Fixing easily exploitable, easily fixed bugs should be prioritized over finding the most obscure vulnerability.</li><li><strong>Built for InfoSec.</strong> It only takes a few minutes on the RSA trade show floor to know that the security products of old are built for the suit-wearing Fortune 500 CISOs. <em>Built for Developers</em> is a marketing tagline, not a product reality. Jump into any of the market leading security tools and it is quickly apparent that they are not, in fact, built for developers.</li><li><strong>Training &gt; Tooling. </strong>Security teams invest time and effort training developers on how to write secure code. While a noble pursuit, the reality is that you are pushed toward feature delivery and don’t retain enough of their secure coding workshops. Good tooling will always win out over another training day.</li></ul><h3>Engineers Will Own the AppSec of the Future</h3><p>The tide is beginning to shift, with engineers taking hold of the security of their applications. Modern engineering teams know that to ship secure apps, they need to own it themselves. We are in the early days of that shift, with a day soon on the horizon where inefficient InfoSec models for application security will become a relic of the past.</p><p>As we talk to the developers who are on the cutting edge of this shift, we are seeing the following trends:</p><ul><li><strong>Finding Security Bugs is Shifting Left. </strong>As with any bug, it is best to find and fix earlier in the development process. Finding a bug in local dev and hammering away on a quick fix is easy. When a bug breaks a build or is found in production, that is a different story. The best engineering teams are adding application security checks at commit and merge and equipping their developers with the tools to troubleshoot quickly when a bug is found.</li><li><strong>Triage and Fix Lives with Those Best Equipped.</strong> If you wrote the code, you are typically the best equipped to make a call on the security risk of a particular bug and to instrument a fix. Even better is when the fix is so simple that it erases the cognitive load of defining the risk, but the bug can be found and fixed while still in local dev.</li><li><strong>Fixing While in Context Drives Speed.</strong> No more getting alerted on security bugs for code you wrote months ago. Fixing a bug while you have the context of the part of the code base you are working on drives simplicity and efficiency.</li><li><strong>Security == Quality, and Engineering knows Quality.</strong> Your engineering team knows how to ship high quality applications with speed and efficiency. In the same way that teams would not push UI bugs into production, security bugs can be fixed before the latest release goes live. Secure code is quality code.</li></ul><h3>The New Breed of Security Tooling</h3><p>The application security shift has already begun. There has been incredible progress on what makes a best-in-class engineering program over the past two decades. Engineers own the end to end building, delivery, operation, and quality of their applications, and the time has arrived for you to own the security as well.</p><p>This shift, however, requires a new breed of security tooling. The tools that aim to serve the CISO first, to the detriment of engineers, will no longer cut it. The products that carry outrageous price tags but have not kept up with the shift in how software is created and delivered will have to be phased out. Here at StackHawk, we say, “This is not security for security people.” As long as application security tools are built for InfoSec teams, they will lack the features that are needed to truly serve you, the modern software engineer.</p><p>We created StackHawk to simplify the process of building and delivering secure code. We are dead set on creating the best security focused dev tool out there, ensuring that the same people who write the code are equipped to ensure it is secure. We are excited about what we have built already and we are just getting started.</p><p><em>Originally published at </em><a href="https://www.stackhawk.com/blog/application-security-is-broken/"><em>https://www.stackhawk.com</em></a><em> on May 20, 2020.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d90fcea2d130" width="1" height="1" alt=""><hr><p><a href="https://medium.com/stackhawk/application-security-is-broken-d90fcea2d130">Application Security is Broken.</a> was originally published in <a href="https://medium.com/stackhawk">StackHawk</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>