Tag: web application

  • Cosmonic Unveils PaaS for Building Wasm Applications

    Cosmonic Unveils PaaS for Building Wasm Applications

    Cosmonic today at the KubeCon + CloudNativeCon North America conference unveiled a platform-as-a-service (PaaS) environment for building cloud-native applications using Web Assembly.

    Based on the open source wasmCloud distributed computing environment now being advanced under the auspices of the Cloud Native Computing Foundation (CNCF), the Cosmonic PaaS gives developers access to a lightweight environment that makes it simpler to quickly build applications that can run anywhere.

    Cosmonic CEO Liam Randall said a PaaS enables developers to achieve that goal by making databases and other non-functional services available via an abstraction layer that eliminates the need for developers to provision these resources themselves.

    Designed to be deployed on any cloud service or on-premises IT environment, the Cosmonic PaaS also enables developers to define their own laptops, cloud resources or entire data center by combing resources to create Constellations. Cosmonic also enables developers to build a Super Constellation by adding customer-hosted components to the services provided by Cosmonic.

    Originally developed under the auspices of the World Wide Web Consortium (W3C) for building browser applications, Wasm is a portable binary instruction format for building software that describes a memory-safe, sandboxed execution environment. The wasmCloud project was created by Cosmonic to provide an open source application runtime that hosts components, written as Wasm modules, that can then be loosely connected to build applications. Cosmonic reports there are now more than 100 members of the wasmCloud community.

    The Cosmonic PaaS extends the capabilities provided by wasmCloud so developers can now more easily build Wasm applications via an abstraction layer defined by Cosmonic. Those applications are also more secure than applications built using previous software artifacts because all Wasm code is executed in a stateless and reactive sandbox that prevents malware from moving from one software component to another.

    It may be some time before Wasm becomes the preferred artifact for building applications, but it’s clear the walls that have separated one IT platform from another are about to crumble. Every earlier format for building applications locked developers into a specific platform. Wasm is the first software artifact that enables applications to run on any platform, including Linux and Windows, without any modification required.

    Once applications become much more portable, the longstanding goal of writing an application once and then deploying it anywhere may finally be achieved. Just as importantly, those applications will run in a memory-safe sandbox that is more secure than what can be enabled in legacy IT platforms. In fact, as more organizations review the security of their software supply chains, they may decide to accelerate their embrace of Wasm to build more secure applications.

    Obviously, Wasm has major implications for DevOps teams, and Randall said Cosmonic is working toward integrating its PaaS with multiple continuous integration/continuous delivery (CI/CD) platforms.

    It’s not clear how quickly Wasm will drive a transition to another era of computing, but the ramifications for how IT is managed in the next era of cloud-native computing could be profound. It remains to be seen how quickly developers are willing to embrace yet another software artifact for building and deploying applications. What is clear is that there are an increasing number of platforms that will make it possible to more easily embrace Wasm.

  • Web Application Firewalls Aren’t Protecting Cloud-Native Apps

    Web Application Firewalls Aren’t Protecting Cloud-Native Apps

    Your web application firewall (WAF) is humming at the edges of your network, faithfully blocking malicious attacks before they can do any harm.

    Better yet, it’s a next-generation WAF (NG-WAF). It consists of signatures, rules, and a sprinkle of machine learning to protect your applications (and user data) from harm. You’ve got it covered, correct?

    Yeah, right.

    You’re a security expert. You don’t take anything at face value. How do you know for sure your applications are protected?

    And what if you have cloud-native applications — microservices, HTTP requests flying around, multiple touchpoints for each user request? Can an NG-WAF protect all of these apps from external and internal attacks?

    We’ve discovered the answer. Let’s take a look at what NG-WAFs do well, what they struggle with, and whether a solution makes up for their gaps.

    The Challenge of Traditional Web Application Firewalls

    According to OWASP:

    A “web application firewall (WAF)” is an application firewall for HTTP applications. It applies a set of rules to an HTTP conversation. Generally, these rules cover common attacks such as Cross-site Scripting (XSS) and SQL Injection.

    Modern applications are more transparent than traditional web applications. Focusing on speed and agility of development — Continuous-Integration, Continuous-Delivery (CICD), and DevOps replacing the waterfall development model — developers tend to use open-source projects to save development time and cost.

    This transparency, ease of access, and incredible detail in documentation make the modern applications attractive targets. The frequent changes in applications make it almost impossible to detect and secure every vulnerability.

    WAFs have added new features over the years, but the backbone of their detection still lies in their signatures or rules. The question is: have WAFs indeed adapted to the needs of cloud-native applications?

    Applications have evolved from massive monoliths to microservices and distributed architectures. They now live virtually in any combination of public, private, or hybrid cloud. The new challenges and threats brought on by distributed architectures have given rise to the NG-WAFs.

    Network firewalls underwent a similar transition, where the Next-Generation Firewalls (NGFWs) introduced a new perspective of looking at firewall traffic with deep packet inspection and attack-centric detection models.

    The next generation WAFs have been frequently defined with three principal characteristics:

    • Detection is based on the application and the attacker’s behavior.
    • Going beyond signatures to identify anomalies and fundamental attacker actions.
    • Cloud-native deployment supporting various cloud platforms, APIs, and microservices architecture
    NG-WAF

    What NG-WAFs Solve

    NG-WAFs propose to solve the new problems introduced by changing application architectures.

    How well have they done? Let’s start by reviewing what NG-WAFs do well.

    Increased Cost to Attackers

    Attackers have a distinct advantage — they don’t play by the rules.

    We live in an age when you can connect almost any device in your home to the internet. Unfortunately, many IoT devices don’t take security measures, which means attackers are salivating at the opportunity.

    Malicious actors try to mask their origin and evade detection using an army of “bots.” Yes, they’re attacking you with DVRs, cameras, and lightbulbs.

    NG-WAFs take a fresh approach of correlating such behavior to detect the attackers and block them, thus increasing the cost for attackers and partly deter the script kiddies.

    Layered Protection: The In-depth Defense

    Defense in Depth increases system security by using a multi-layered approach with intentional redundancies. It’s commonly referred to as the “castle approach” because it mirrors a medieval castle’s layered protection. If one layer fails, another is waiting to take its place.

    NG-WAFs have evolved to protect at multiple levels, including the traditional perimeter and the newer approach of embedding alongside the applications. These layers make an attacker’s job much more difficult and expensive.

    Machine Learning and Behavioral Analytics with Automated Policy Learning

    NG-WAFs aggregate detection from multiple applications to understand attackers from a broader perspective to contextually score them. Using machine learning and behavior analytics on the aggregated data, NG-WAFs automatically disable signatures that would trigger false positives and update the application policies accordingly.

    Virtual patching

    You ideally want to identify and fix every vulnerability found in your code. But real-world business situations dictate that not all vulnerabilities will be fixed quickly or at all.

    A few NG-WAFs support virtual patching to prevent attackers from exploiting critical vulnerabilities until an official fix is available.

    Cloud-native Support

    NG-WAFs now support deployment in a public, private, or hybrid cloud. The NG-WAFs automatically integrate with a containerized approach to scale security natively and elastically. They distribute nodes all over the world to maximize coverage without increasing latency.

    What NG-WAFs Have Failed to Solve

    NG-WAFs have made strides in securing applications. They’ve used defense-in-depth to make successful attacks increasingly tricky to pull off.

    They’ve incorporated new architectures and virtual patching to match the pace and style of current app development. But they haven’t solved every problem.

    Let’s look now at what NG-WAFs are missing that may open up holes in your security.

    Motivated Attackers Can Bypass NG-WAFs

    WAFs introduce obstacles for hackers and penetration testers by making vulnerability finding and exploitation more resource-intensive. However, an experienced hacker or a researcher with enough motivation would probably be able to find ways to bypass it.

    When the application use case becomes complex, it may demand disabling many defenses that produce a higher false positive rate. The more complex a web application is, the bigger its attack surface, and the easier it is to find a bypass for it.

    NG-WAFs Are Vulnerable to Use Case Exploitation

    The same application deployed in different contexts exhibits different behavior. Requests that are harmful for one application may be perfectly normal for the other as user behavior varies for each case.

    NG-WAFs do not have a complete picture of application usage — they cannot detect the business use case. The attack patterns stay hidden within regular traffic and nested protocols. Eventually, the attacker can tune himself to the business traffic and bypass the NG-WAFs resulting in a window of vulnerability and delay in breach detection. Straightforward implementations for detecting such use case exploitation often result in a high rate of false positives and false negatives. Further, customers rarely use all of the available features and rules in modern NG-WAFs.

    Machine Learning and Behavioral Analysis Are Limited to Perimeter Defense

    NG-WAFs have evolved from WAFs and base themselves on a “perimeter defense” model — it guards only against malicious traffic originating outside the network. However, this model fails if an attack comes from within – a common occurrence given the wide variety of ways users can connect to an internal network.

    The new “stay at home” normal and increased risk of insider threats has led enterprises to adopt the Zero Trust model. It is essential to monitor the external traffic along with the internal flow and state of the applications.

    Missing Runtime Protection

    Malicious hackers are attacking all the application stack tiers, be it web, memory, or database. By design, NG-WAFs are limited at the edge of the application module and cannot protect the application at runtime. With this knowledge, the attacker could also circumvent the virtual patch defenses once the vulnerability is known to them by altering their attack method or mingling with the business traffic.

    Monitoring blind spots

    Monolithic frameworks base the visibility into the application on logging frameworks. Want to know what’s happening? Only one directory to check.

    Modern applications built on microservices and serverless introduce advantages to application development, but there’s also the cost of reduced visibility. You can monitor each service individually, but one can quickly lose sight of the global system behavior.

    A single request to the modern application can create a chain of calls behind the scenes. What appears simple can sometimes be incredibly complicated. For example, take a look at what happens inside Netflix when you hit play during your latest binge.

    This call chain generates a massive amount of data along its flow path. External applications have trouble ingesting it all. Instead of solving this problem, most NG-WAFs limit the amount of data they can capture and process, introducing blind-spots the attackers can leverage to bypass them.

    How to Protect Cloud-Native Applications

    Cloud-native microservice architectures introduce drastic benefits but are also challenging to defend. While NG-WAFs have made some strides, they still fall short in several crucial areas. To comprehensively protect your cloud-native apps you should look for a solution that seamlessly provides both security observability and intelligent threat detection. Look for solutions that offer:

    • end to end distributed tracing and visibility, increasing the accuracy and depth of attack detection without extra overhead
    • features that establish baselines for user behavior, API logic, and data flow to identify anomalies
    • the ability to block business use case abuses, insider attacks, and threat actors, even in distributed systems
    • visibility that provides a complete picture of how data (especially sensitive business and personal data) moves throughout your application so you can see problem areas before they become exploits
    • discovery and protection of the complete eco-system of your microservices

    If you’d like to learn more about TraceableAI you can view a recorded demo of Traceable in action.

  • Node.js Foundation Embraces HTTP/2

    Node.js Foundation Embraces HTTP/2

    The latest version of Node.js will significantly increase the DevOps challenges surrounding the most widely used version of JavaScript in the enterprise. Node.js 8 adds the ability to support HTTP/2, a major revision of the core internet protocol that, in addition to being significantly faster, enables developers to make multiple requests over a single connection as well as set up pipelines for making a series of requests.

    Myles Borins, director of the Node.js Project and member of the technical steering committee at The Node.js Foundation, notes that while HTTP/2 eventually will be supported by multiple programming languages, DevOps teams most likely will encounter it first in web and mobile applications built using Node.js.

    Borins says HTTP/2 also should go a long way to accelerating the adoption of microservices applications—the majority of which are being built using Node.js.

    Node.js 8, available under a Long-Term Support (LTS) license, is 20 percent faster than its predecessors, Borins says. It is based on the JavaScript V8 engine that makes use of Turbofan and the Ignition compilers and interpreters, which equates to lower memory consumption and faster startup time across Node.js applications.

    Other new features include an Async/Await capability that allows developers to write more linear code versus relying on callbacks and a series of Experimental ES Modules that provide a standard pattern for writing modular JavaScript code that can run on both the web and in Node.js.

    Node.js 4 is now scheduled to be designated for end-of-life status in April, and Node.js 6 will face a similar fate soon after. The Node.js Foundation is encouraging organizations that have deployed Node.js applications to refresh them because security patches and updates soon no longer will be available for the core engines used in Node.js 4 and 6 applications. Node.js API (N-API), a project that enables modules to run against new versions of Node.js, is still considered experimental. That project is being lead jointly by Google, IBM, Intel, Microsoft, nearForm, NodeSource and individual contributors.

    The Node.js Foundation also announced that work has begun on Node,js 9, which is focused on modernizing legacy application programming interfaces (APIs) and implementing a new error system that associates a unique code with all errors in place of relying on traditional error messages.

    The Node.js Foundation estimates there more than 9 million instances of Node.js deployed across the web today, so managing Node.js applications across their life cycle has become a significant DevOps challenge. While Node.js is not the only programming language gaining momentum across the enterprise, the Node.js community is highly focused on increasing the robustness and manageability of Node.js applications in a way that should eventually please even some of the most hardcore fans on rival languages such as Java or even COBOL.

    — Mike Vizard