<?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 Omer Levi Hevroni on Medium]]></title>
        <description><![CDATA[Stories by Omer Levi Hevroni on Medium]]></description>
        <link>https://medium.com/@omerlh?source=rss-b1e3822cf24b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*rZXCGuZb7C0dHzIJsmNttQ.png</url>
            <title>Stories by Omer Levi Hevroni on Medium</title>
            <link>https://medium.com/@omerlh?source=rss-b1e3822cf24b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 22:31:49 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@omerlh/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[Threat Modeling for AI Agents: Four Questions, One ADR]]></title>
            <link>https://medium.com/@omerlh/threat-modeling-for-ai-agents-four-questions-one-adr-45458750ebea?source=rss-b1e3822cf24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/45458750ebea</guid>
            <dc:creator><![CDATA[Omer Levi Hevroni]]></dc:creator>
            <pubDate>Fri, 23 Oct 2026 08:42:51 GMT</pubDate>
            <atom:updated>2026-10-23T08:42:51.887Z</atom:updated>
            <content:encoded><![CDATA[<p>In 2019 the hard part was never the method. It was getting anyone to write the thing down.</p><p>In 2019 I booked a three-hour threat modeling session. Six people came. We drew a diagram, argued about one arrow, and ran out of time before anyone asked what could go wrong. That was the good session.</p><p>I believed in threat modeling then, and I could not make it stick. The method was fine. Everything around it wasn’t.</p><p><strong>Short version:</strong> AI agents turned threat modeling from a meeting into a section of the architecture decision record (ADR). Adam Shostack’s four questions still do the work. They just got a reader that never gets tired.</p><h3>What is threat modeling, and why did it never get buy-in?</h3><p>Threat modeling means asking Shostack’s <a href="https://shostack.org/files/papers/The_Four_Question_Framework.pdf">four question framework</a> about a system: what are we working on, what can go wrong, what are we going to do about it, and did we do a good job?</p><p>In 2019 that started with a long session. Get the right people in a room, draw the system, argue about what is in the diagram, run out of time, book a second session.</p><p>Then came the part nobody mentions in the talks: <strong>chasing developers.</strong> For the diagram, for the answers, for the follow-ups, for someone to fix what we found. Every session cost a few hours from several people with a deadline, and the output was a document that was stale by the next sprint.</p><p>So there was no buy-in. Why would there be? To a developer, threat modeling was a meeting that produced homework. I tried to fix it from the tooling side: I wrote about <a href="https://omerlh.github.io/archive/threat-modeling-as-code/">threat modeling as code</a>, with the model in a repo and changes reviewed in PRs, and about <a href="https://omerlh.github.io/archive/do-we-really-need-threat-modeling/">scaling it with templates</a>, after watching <a href="https://www.oreilly.com/library/view/threat-modeling/9781492056546/">Izar Tarandach’s</a> talk on doing it continuously.</p><p>Good ideas, both. Both had the same hole: <strong>someone still had to write and maintain the thing.</strong> The someone was me, and I ran out of hours. (Turns out “I’ll update the model next quarter” ages exactly like “I’ll run the scanner next quarter”.)</p><h3>How do AI agents change threat modeling?</h3><p>Something changed, and it had nothing to do with security.</p><p>Working with coding agents is mostly <strong>writing</strong>. You write the spec. You write the context. You write down the decisions, because an agent has no hallway to overhear them in. On my team we keep <a href="https://www.cognitect.com/blog/2011/11/15/documenting-architecture-decisions">architecture decision records</a>, the format Michael Nygard proposed in 2011, in a repo for exactly this reason: they make the agent better. It reads why we chose this database, what we ruled out and what we agreed never to do before it writes a line. Duncan Davidson <a href="https://duncandavidson.com/agents-love-decisions">makes the same case</a>: decision records give coding agents the intent they would otherwise guess from the code.</p><p>That’s the buy-in I never had: nobody needs convincing to document a system when the documentation makes the agent work better.</p><p>And the second realization: <strong>an agent is also good at the part I ran out of hours for.</strong> Given the code and a diff, it can draft the diagram, propose what can go wrong, and point out when a change touches something the model doesn’t cover. (I’m not the only one trying: OWASP has an incubator project, <a href="https://owasp.org/www-project-lets-threat-model/">Let’s Threat Model</a>, that takes an agentic approach to the same problem.) No scheduling, no chasing, and far less drift, because the reader checks every PR.</p><p>What I needed in 2019 wasn’t a better tool. It was a reader that never gets tired, and a team that writes things down anyway.</p><h3>Are the four questions useful beyond threat modeling?</h3><p>Yes. They turned out to be bigger than a threat modeling method. They fit any change, and with agents in the loop I use them three ways.</p><h3>A. To judge an ADR</h3><p>An ADR says what we decided. The four questions say whether it’s a good decision.</p><ul><li><em>What are we working on?</em> Does the ADR say what system it affects and where the boundaries are?</li><li><em>What can go wrong?</em> Does it name failure modes, or only the happy path?</li><li><em>What are we going to do about it?</em> Is each risk mitigated, accepted on purpose, or ignored by accident?</li><li><em>Did we do a good job?</em> How would we know in six months that this was right?</li></ul><p>An ADR that can’t answer these isn’t done. An agent can run this review on every ADR PR and never feels awkward asking.</p><h3>B. As a pre-mortem</h3><p>Borrowing from Gary Klein’s <a href="https://hbr.org/2007/09/performing-a-project-premortem">pre-mortem</a>, where the team imagines the project already failed and asks why, question two becomes something you ask <em>before</em> the work, not after the incident.</p><p>Before an agent starts a task that touches auth, data flows or anything external, it answers “what can go wrong?” first, from the ADRs. Humans skip this step under deadline pressure. An agent can be instructed not to, and a CI check can verify that it didn’t.</p><h3>C. To define how we validate AI work</h3><p>This is the one I care about most. If agents write more of our code, the review can’t be “a human reads every line”. Teams are already pushing that way: Simon Willison <a href="https://simonwillison.net/2026/Feb/7/software-factory/">describes</a> StrongDM’s “software factory”, where specs and scenarios drive agents and a harness (the tests that grade the agent’s work) checks the result.</p><p>In that world, question four is the whole game: <strong>did we do a good job?</strong> (Shostack meant it as a retrospective question. Turning it into a machine-checkable test is my extension.) Which mitigations must hold? Which scenarios must never happen? Those answers go in the repo as tests and checks, written before the work.</p><p>Instructions alone won’t hold them. Claude Code’s own docs say CLAUDE.md is <a href="https://code.claude.com/docs/en/memory">context, not enforced configuration</a>, and recommend a hook to block an action for certain. So question four needs real enforcement: CI, hooks, and branch protection with required reviewers on the checks themselves. An agent that can rewrite the check to make its own PR pass hasn’t done a good job. It has gamed the grader.</p><h3>Threat modeling is dead. Long live threat modeling.</h3><p>The version I tried to sell in 2019, the workshop, the whiteboard, the separate document, is dead. I don’t miss it.</p><p>What replaces it is nothing fancy, and that’s the point. For most changes there’s no separate threat modeling <em>process</em>. There’s a design, and the design carries its threat model the way it carries a database choice: <strong>it’s part of the design, not a separate activity.</strong></p><p>In the repo that means:</p><ul><li><strong>The four questions live inside the ADR.</strong> What we’re working on, what can go wrong, what we’ll do about it, how we’ll know. An ADR with an empty “what can go wrong” is an incomplete ADR.</li><li><strong>Same PR as the decision.</strong> Same markdown, same review, same people. Nobody schedules anything.</li><li><strong>Read by the agent like everything else.</strong> It’s context for the next change, so drift gets noticed faster, though not always noticed.</li></ul><p>Nothing new for the developer to learn or open. The threat model is inherited from the design, the way a service inherits its logging setup.</p><h3>A GitHub Action that reviews the ADR</h3><p>The automation I wanted is small: a GitHub Action that runs Claude Code on PRs that add or change an ADR, asks the four questions, and comments with feedback. It’s a reviewer, not a gate. It drafts, people decide.</p><p>I put a ready-to-use example on GitHub: <a href="https://github.com/omerlh/adr-threat-review">omerlh/adr-threat-review</a>. It’s a starting point, not a copy of what runs at work. Ours has tweaks that fit our own repos and conventions, so treat this one as the simple version: copy the workflow, the prompt and the ADR template, and adjust them to your team.</p><p>To try it, I wrote ADRs for <a href="https://owasp.org/www-project-juice-shop/">OWASP Juice Shop</a>, the shop that is vulnerable on purpose. ADR 0001 is a decent one: the server owns the basket, with tests. Then I opened <a href="https://github.com/omerlh/adr-threat-review/pull/1">a pull request</a> with a deliberately lazy ADR 0002, “keep the session token in local storage”, where the answer to “what can go wrong?” is “Nothing. This is how most single-page apps do it.”</p><p>The review pushed back on every question. On question two it said the template already rules out “Nothing” as an answer, and listed what was missing: a script injected into the page reading the token, tokens valid until logout with no way to revoke them, and tokens left on shared machines. On question four it pointed out that “login works in the manual test” checks that login works, not that any risk is controlled.</p><p>The comment I liked best was one no single-ADR review would give, because it read the other ADR too:</p><blockquote><em>ADR 0001 mitigates a stolen token with “Session tokens expire, and checkout asks for the token again.” ADR 0002’s tokens that never expire break that mitigation.</em></blockquote><p>Its verdict was “needs a human threat modeler”, because the ADR puts a long-lived credential somewhere scripts can read it. That’s the kind of catch that used to need the six people in the room.</p><p>It’s one example on a toy repo, written by me to be flawed, so treat it as a demo, not a benchmark, and not a report on our production setup.</p><p>The safety defaults are in the README. It runs on pull_request only, skips fork PRs, has a token that can only comment, treats the ADR text as untrusted data, and pins every action to a commit SHA. It also has no API key: the job trades its GitHub OIDC token for a short-lived Claude token through workload identity federation, so there&#39;s no static secret to leak. One catch when I set it up: GitHub&#39;s token subject now carries numeric IDs, so a rule written with the repo name alone never matched.</p><h3>Where I’m still unsure</h3><ul><li><strong>One ADR is not the whole system.</strong> This is the weakest part of the argument. Trust boundaries, data flows that span services and risks that appear only when decisions combine are invisible in any single ADR. Each can pass the four questions while the system is still vulnerable. So I’d keep a thin system-level view (diagram, trust boundaries, assets) that the ADRs link to and the agent re-checks. “No separate process” is true for the delta, not for the whole picture.</li><li><strong>Know when to call a human.</strong> A new trust boundary, a new class of sensitive data or a new external exposure still deserves someone who threat models for a living.</li><li><strong>Confident garbage.</strong> An agent will write a polished model of a system it misunderstood. One <a href="https://arxiv.org/abs/2505.04101">study of LLMs classifying 5G threats into STRIDE categories</a> found them useful but in need of human oversight. Humans still own questions one and two.</li><li><strong>It’s non-deterministic and it costs tokens.</strong> The same ADR may get different feedback twice. That’s fine for a reviewer, and a reason it can’t be a gate.</li><li><strong>Keep it boring on purpose.</strong> A threat model describes where you’re weak. No hostnames, credentials or anything you’d hate to see in a leaked repo.</li><li><strong>Agents are a new attack surface.</strong> Prompt injection and over-trusted tools need their own threat model. Shostack <a href="https://shostack.org/blog/threat-modeling-technique-survives-ai-disruption/">argues</a> the questions still apply, and his <a href="https://shostack.org/blog/threat-modeling-2nd-edition/">second edition</a>, due in February 2027, adds chapters on using LLMs to threat model and on threats to LLMs. That’s another post.</li></ul><h3>Steal this</h3><ol><li>Add the four questions to your ADR template, so every decision answers them.</li><li>Have an agent review your next ADR PR against them, for example by copying <a href="https://github.com/omerlh/adr-threat-review">the example Action</a> and adapting it. Fix what it got wrong; the correction is the valuable part.</li><li>Before an agent task on something sensitive, make it answer question two first.</li><li>Write question four as a check before the work starts, and protect that check with required reviewers.</li></ol><p>In 2019 I couldn’t get anyone to join the session. In 2026 the team writes the inputs every day, and the reader doesn’t need a calendar invite.</p><p><em>Related: </em><a href="https://omerlh.github.io/posts/security-is-easy-now/"><em>Security got easy</em></a><em>, where I let an agent test a web app with ZAP.What was the longest threat modeling session you ever sat through? Tell me, and I’ll tell you whether an agent could have done it.</em></p><p><em>Originally published at </em><a href="https://omerlh.github.io/posts/threat-modeling-for-agents/"><em>https://omerlh.github.io</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=45458750ebea" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Using Zaproxy for Debugging]]></title>
            <link>https://medium.com/@omerlh/using-zaproxy-for-debugging-85b038fb9a37?source=rss-b1e3822cf24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/85b038fb9a37</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[debugging]]></category>
            <category><![CDATA[zaproxy]]></category>
            <dc:creator><![CDATA[Omer Levi Hevroni]]></dc:creator>
            <pubDate>Wed, 15 May 2019 19:21:57 GMT</pubDate>
            <atom:updated>2019-05-15T19:21:57.762Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*v46Zt61DoSidEu8P.jpg" /><figcaption>A regular debugging process</figcaption></figure><p>One day I was debugging a really nasty bug that happens only in our iOS app. I was really frustrated because I couldn’t figure out why it happens. Everything looks good when debugging the iOS code, but for some reason — the server failed to deserialize the request body. I freaked out — nothing I tried seems to solve the issue. If only there was an easy way to view the actual request and response, maybe I could understand what the issue was…</p><p>When handling such bugs, a proxy can help investigate it: A proxy can inspect the traffic and print it an easy to understand manner. There are a lot of available proxies you can use (like <a href="https://www.charlesproxy.com/">Charles</a> (commercial) or <a href="https://www.telerik.com/fiddler">Fidler</a>), but <a href="https://github.com/zaproxy/zaproxy">OWASP Zaproxy</a> (Zap) is the best open source proxy that I know.</p><p>After setting up the proxy (this <a href="https://www.omerlh.info/2019/05/15/debugging-ios-apps-with-zaproxy">post</a> explains how to achieve that in 3 simple steps!), I spotted the bug immediately. It was a simple serialization issue — our iOS app use camel case, while the server expects Pascal case. Such a bug is a lot harder to detect without a proxy…</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=85b038fb9a37" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Can Kubernetes Keep a Secret? It all depends what tool you’re using]]></title>
            <link>https://itnext.io/can-kubernetes-keep-a-secret-it-all-depends-what-tool-youre-using-498e5dee9c25?source=rss-b1e3822cf24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/498e5dee9c25</guid>
            <category><![CDATA[gitops]]></category>
            <category><![CDATA[secrets]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[devsecops]]></category>
            <dc:creator><![CDATA[Omer Levi Hevroni]]></dc:creator>
            <pubDate>Thu, 31 Jan 2019 11:39:39 GMT</pubDate>
            <atom:updated>2019-02-02T21:19:13.031Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_bFrDFQfycUjLt-k.png" /></figure><p>At Soluto, we have super-devs who have full ownership: from writing code to deploying it to monitoring. When we made the shift to <a href="https://kubernetes.io/">Kubernetes</a>, we wanted to keep our devs independent and put a <a href="https://blog.solutotlv.com/deploying-kubernetes-like-a-pro/">lot of effort into allowing them to create services rapidly</a>. It all worked like a charm — until they had to handle credentials.</p><p>This challenge leads us to build <a href="https://github.com/Soluto/kamus">Kamus</a> — an open source, <a href="https://www.weave.works/blog/gitops-operations-by-pull-request">GitOps</a>, zero trust, secrets solution for Kubernetes applications. Kamus allows you to seamlessly encrypt secret values and commit them to source control. But before diving into how Kamus works, let’s do a quick recap of Kubernetes native secrets solution, and why we even need Kamus.</p><p>As you may already know, Kubernetes has a built-in object for secret management, with the super surprising name “Secret”. A <a href="https://kubernetes.io/docs/concepts/configuration/secret/">Kubernetes secret</a> is a simple object that’s stored securely (e.g. encrypted at rest) by the orchestrator and can contain arbitrary data in key-value format. Here’s an example of what a Kubernetes secret looks like:</p><pre>apiVersion: v1<br>data:<br> super-secret: aHR0cDovL2pvYnMuc29sdXRvLmNvbS9hcHBseS95MDVYSXEvUHJvZHVjdGlvbi1FbmdpbmVlci1EZXZPcHM=<br>kind: Secret<br>metadata:<br> name: sensitive-data<br> namespace: default<br>type: Opaque</pre><p>As you can see, we have the type (Secret) and our data. The value is base64 encoded, so we can also store binary data like certificates. Kubernetes makes it easy to consume secrets by letting you simply mount them onto your container, either as env var — not recommended — or as a file.</p><h3>What’s wrong with Kubernetes plain Secrets?</h3><p>Why do we need another solution? First of all, Kubernetes secrets are base64 encoded, not <em>encrypted</em>. This means you cannot commit these files into source control as-is (and this is even specified <a href="https://kubernetes.io/docs/concepts/configuration/secret/#security-properties">in the docs</a>). Anyone with access to the repository can grab the secrets and use the secret value (unless this is a threat you’re willing to accept, which can be valid under certain circumstances). So we still need a simple way to store this secret and upload it to production, ideally without any manual operation.</p><p>Which leads to my second point: usability. Secrets are critical for normal execution of a service, and a change in one of them can lead to production issues. You need to have good visibility into these secrets — who changed them, when, and what changed — so you can investigate production issues. This is why I’m so much in favor of GitOps, where everything is audited via git. Yes, Kubernetes has audit mechanism, but it’s not as straightforward as git. So when it comes to usability, we need a way to modify secrets that will be transparent and easy to follow.</p><p>Thirdly, consider how your service consumes secrets. In Kubernetes, you can consume a secret in one of two ways: mount the secret as an <a href="https://kubernetes.io/docs/concepts/configuration/secret/#using-secrets-as-environment-variables">environment variable</a> or as a <a href="https://kubernetes.io/docs/concepts/storage/volumes/#secret">volume</a>. Mounting the secret as environment variable is the simplest method, but not everyone feels comfortable with storing sensitive data in environment variables (check out this <a href="https://twitter.com/omerlh/status/1079088158929797121">twitter thread</a> to see some opinions).</p><p>For this reason, some people (including myself) prefer to mount <a href="https://kubernetes.io/docs/concepts/storage/volumes/#secret">secret as volumes</a>. This allows you to access the secret content as a normal file in the container. Kubernetes creates one file per key in the secret’s data and puts the decoded value as the file content. This might work when having one or two keys, but the more keys you have, the harder it gets — you need to read all these files from the application’s code. This is why we usually end up creating a configuration file, base64 encode it, and store it as a single secret value. However, this makes it even harder to understand what changed.</p><p>Lastly, Kubernetes has great RBAC support, but it has its disadvantages. The existing permissions for secrets are <em>get </em>and <em>set </em>(as well as others that are less relevant to this discussion). Secrets are encrypted at rest, but there is no permission saying “allow the user to get the secret encrypted”. Once a user is allowed to get a secret, she will get it decrypted. Ideally, we’d like to have a zero-trust system where once you encrypt a secret, there’s no easy way to decrypt it. Currently, there’s no easy way to achieve that with Kubernetes.</p><h3>Alternatives to Kubernetes Secrets</h3><p>There are a few good alternatives out there, like <a href="https://github.com/bitnami-labs/sealed-secrets">Sealed Secrets</a> and <a href="https://github.com/futuresimple/helm-secrets">Helm Secrets</a>. Both solutions let you create encrypted secrets that can be committed to source control, and decryption to regular Kubernetes secrets occurs later on (either on the CD or in the cluster). But these solutions aren’t perfect, either. There’s no support for one-time encryption because, in order to modify a value in the secret, you must decrypt its content. And all the usability issues we had before still exist.</p><h3>Introducing Kamus</h3><p>One day while working on <a href="https://github.com/OWASP/glue">Glue</a>, I used Travis secrets <a href="https://docs.travis-ci.com/user/encryption-keys/">encryption solution</a>. If you’re unfamiliar with how Travis handles secrets, the server creates an RSA key pair per repository and then exposes the public key. Devs can use the public key to encrypt values that later on can only be decrypted by Travis. This made me think: what if I create a similar solution for Kubernetes? What if I can have a specific RSA key-pair per deployment so I can leverage the same mechanism? And the result… was Kamus.</p><p>Let’s take a look at how we can use Kamus, and then deep-dive into how it works and the security of the solution. Kamus encrypts secrets for a specific <a href="https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/">service account</a>, which is later used by a pod to authenticate Kamus and decrypt them. So the first thing we need to do is to create a service account:</p><pre>kubectl create sa dummy</pre><p>Now we can use <a href="https://github.com/Soluto/kamus/tree/master/cli">kamus-cli</a> to encrypt our super secret value for this service account:</p><pre>kamus-cli encrypt --secret super-secret --service-account some-sa --namespace some-ns --kamus-url <a href="https://kamus.my-company.com/">https://kamus.my-company.com</a></pre><p>The returned value will be the encrypted value. We can now safely commit it to git, and in runtime, use Kamus API and the token of the pod’s service account to decrypt this value. If a different pod with a different service account tries to decrypt the value, the operation will fail.</p><p>Decrypting a secret is simple — just use the <a href="https://github.com/Soluto/kamus/tree/master/init-container">Kamus init container</a>. The init container will read all the encrypted secrets, use the service account token to decrypt the values with Kamus, and write the decrypted values in a temporary location. To see this in action, try running the <a href="https://github.com/Soluto/kamus/tree/master/example">example app</a>.</p><h3>Ready to give it a try?</h3><p>We at Soluto have been using Kamus in production for the last six months. This has significantly improved the developer experience, and now using secrets is a fun and simple task. This is why we decided to open-source Kamus. Getting started with it is simple — just install it with Helm on a Kubernetes cluster, and you’re done:</p><pre>helm repo add soluto <a href="https://charts.soluto.io/">https://charts.soluto.io</a></pre><pre>helm install kamus soluto/kamus</pre><p>You can check out our <a href="https://github.com/Soluto/kamus/blob/master/docs/install.md">installation guide</a> for a production-grade deployment.</p><p>Security is important to us and is why we built Kamus. Since we understand how sensitive a project like Kamus can be, as part of the open source release, we also released a <a href="https://github.com/Soluto/kamus/tree/master/docs/features">threat model</a>. This is where you’ll find all the different threats we detected and how Kamus mitigates these threats. If you find a security issue, we’d like to hear about it — please check out the <a href="https://github.com/Soluto/kamus/blob/master/security.md">security.md doc</a> to learn how to report security issues to us.</p><p>Keeping secrets secure is critical, but not always simple. Kamus solve this problem by providing a secure GitOps solution to the problem. It lets you tell a secret to Kubernetes, and makes sure that no one else knows this secret. The rest is up to you — will you give Kamus a try?</p><p><em>Originally published at </em><a href="https://blog.solutotlv.com/can-kubernetes-keep-a-secret?utm_source=medium"><em>Soluto Engineering Blog</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=498e5dee9c25" width="1" height="1" alt=""><hr><p><a href="https://itnext.io/can-kubernetes-keep-a-secret-it-all-depends-what-tool-youre-using-498e5dee9c25">Can Kubernetes Keep a Secret? It all depends what tool you’re using</a> was originally published in <a href="https://itnext.io/">ITNEXT</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How To: (Continuously) Hacking Your App]]></title>
            <link>https://medium.com/@omerlh/how-to-continuously-hacking-your-app-c8b32d1633ad?source=rss-b1e3822cf24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/c8b32d1633ad</guid>
            <category><![CDATA[devsecops]]></category>
            <category><![CDATA[continuous-integration]]></category>
            <category><![CDATA[security-testing]]></category>
            <category><![CDATA[appsec]]></category>
            <category><![CDATA[mobile-development]]></category>
            <dc:creator><![CDATA[Omer Levi Hevroni]]></dc:creator>
            <pubDate>Thu, 05 Jul 2018 16:52:28 GMT</pubDate>
            <atom:updated>2018-07-05T16:52:28.877Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*mc9fEagyUgNdBlzD.jpg" /><figcaption>It’s not a post about hacking without someone wearing a hoodie (source: <a href="https://pixabay.com/en/hacker-hacking-computer-security-3480124/">Pixabay</a>)</figcaption></figure><p>Yep. Today post is a practical guide: how you can hack a mobile application (that you wrote, otherwise it might be illegal) continuously — meaning, each time a new code is pushed.</p><p>Why?</p><p>For the same reason we’re running tests continuously — so we can know that (a) our app behaves like expected and (b) it continues to behave like that even when the code change. Security should not be different — we’re expecting that our app is secure and that it is keeping to stay secure even when the code change. This is why we need security testing.</p><p>How can we write security tests? There are many ways to do that, but the simplest way is to take a real hacking tool that is used by real hackers (or <a href="https://en.wikipedia.org/wiki/Penetration_test">penetration testers</a>), and run them on our app, continuously. The tool will inspect our app and report about any vulnerability that exists in our code. Today I will focus on one tool — MobSF, explain what it does — and also show how simple it is to run it continuously. In case you’re not interested in the details, check out this <a href="https://github.com/Soluto/mobsf-ci">repo</a>, which contains a step by step guide.</p><h3>MobSF: Introduction</h3><p><a href="http://Mobile Security Framework is an automated, all-in-one mobile application (Android/iOS/Windows) pen-testing framework capable of performing static analysis, dynamic analysis, malware analysis and web API testing.">MobSF</a> (Mobile Security Framework) is:</p><blockquote>an automated, all-in-one mobile application (Android/iOS/Windows) pen-testing framework capable of performing static analysis, dynamic analysis, malware analysis and web API testing.</blockquote><p>MobSF is a web application (which also has RESTful API), and it can be used to scan mobile application. You upload the executable of your application (for example, the <a href="https://en.wikipedia.org/wiki/Android_application_package">apk</a> for Android applications) to MobSF, and then you have a detailed report of all the various security issues in your application.</p><p>To get a feeling of how valuable it can be, let’s take it to a test drive. For the test drive, I’ll use <a href="https://github.com/dineshshetty/Android-InsecureBankv2">InsecureBankV2</a>, which is (like the name implies) an insecure Android application. This is a great use case for intentionally broken application — it can be used to evaluate and compare various security tools. By running the security tool on a vulnerable application, you can assess how many issues the tool detected. This could give you a good indication of the tool’s quality.</p><h3>MobSF: Scanning InsecureBankV2 Manually</h3><p>To run MobSF, we can use the official Docker image:</p><p>docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest</p><p>And now open <a href="http://localhost:8000.">http://localhost:8000</a> in your browser. You should see MobSF welcome page. The next step is uploading InsecureBankV2 apk to MobSF, and pressing scan. The scan can take some time, but when it is finally over, we can go over the report to see all the juicy finding. For the purpose of this post, I’m going to focus only on one thing— security issues related to <a href="https://developer.android.com/guide/topics/manifest/manifest-intro">Android manifest</a>.</p><p>The manifest is where you can define all the <a href="https://developer.android.com/reference/android/app/Activity">activities</a>, <a href="https://developer.android.com/guide/components/services">services</a> and <a href="https://developer.android.com/reference/android/content/BroadcastReceiver">broadcast receivers</a> of your application. Those components can introduce security issues when misconfigured — malicious applications can exploit them to trigger a custom functionality of your app. To find out more about this issue, and how to fix it, you can read this section from the <a href="https://github.com/OWASP/owasp-mstg/blob/master/Document/0x05h-Testing-Platform-Interaction.md">Mobile Security Testing Guide</a> by <a href="https://www.owasp.org/index.php/Main_Page">OWASP</a>. Now that we understood what it is, let’s take a look on the manifest analysis:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SqPwq53f75sFTrG8GWokOQ.png" /><figcaption>MobSF report</figcaption></figure><p>MobSF reported various issues related to the manifest, rank them and provide actionable information — that we can use to fix those issues. This is valuable information — now let’s see how we can get the same information in an automated manner.</p><h3>MobSF: Scanning InsecureBankV2 Automatically</h3><p>MobSF has an API, and we can use this API to perform all the operation we did in the previous step: Upload an APK, start a scan and get a report. The API is documented <a href="https://github.com/MobSF/Mobile-Security-Framework-MobSF/wiki/3.-REST-API-Documentation">here</a>, in case you want to take a look. To create an automated scan, all that is required is:</p><ol><li>Writing a script that interacts with MobSF (perform all the API requests)</li><li>Running it on docker-compose (one container running MobSF, and one running our scan script from the previous step)</li><li>Integrate it with the CI.</li></ol><p>For step 1 &amp; 2, check out this <a href="https://github.com/Soluto/mobsf-ci">repo</a>. It contains all that is required, so all you need to do is (a) clone the repo and (b) run docker-compose up . A step-by-step guide is available on the <a href="https://github.com/Soluto/mobsf-ci">Readme</a>.</p><p>What about CI integration? As all the scan is running on Docker containers, it is really simple to run it on a CI server. This is good, but not enough. We need to fail the build if any security issues found. The developers also need a mechanism to ignore false positives. All this can be solved with <a href="https://github.com/OWASP/glue">OWASP Glue</a> — a tool that eases the integration of security tools into the CI. Glue can parse MobSF’s report and fail the build on any reported issues. Use Docker to run Glue, using the following command (assuming the report file is report.json and it is located in the current directory):</p><pre>docker run -it -v $(pwd):/app owasp/glue:raw-latest ruby bin/glue -t Dynamic -T /app/report.json --mapping-file mobsf --finding-file-path /app/android.json -z 2</pre><p>The command will pass the report produced by MobSF to Glue. Glue will produce nice text output and fail the build if any issue that is medium or higher found. Glue can do a lot more than that — check the <a href="https://github.com/OWASP/glue/blob/master/OPTIONS.md">documentation</a> to find all the different options.</p><h3>Wrapping Up</h3><p>Now, after integrating MobSF into the CI, you can rest assured. Each time someone will push a new code, MobSF will scan the code, and Glue will fail the build on new issues. This will allows you guarantee that your app is secure, and is staying secure over the time — by continuously hacking it.</p><p>And one last note. This post focused on testing Android applications, but MobSF is capable to scan also iOS applications. That mean you can use the same approach, maybe with some customization. If you gave it a try — please share! I’m looking forward hearing about your experience.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c8b32d1633ad" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Guarding Your Packages with Snyk and Icinga]]></title>
            <link>https://medium.com/@omerlh/guarding-your-packages-with-snyk-and-icinga-667798cac6cc?source=rss-b1e3822cf24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/667798cac6cc</guid>
            <category><![CDATA[monitoring]]></category>
            <category><![CDATA[devsecops]]></category>
            <category><![CDATA[package]]></category>
            <category><![CDATA[appsec]]></category>
            <dc:creator><![CDATA[Omer Levi Hevroni]]></dc:creator>
            <pubDate>Wed, 06 Jun 2018 18:24:08 GMT</pubDate>
            <atom:updated>2018-06-06T18:24:08.547Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*fynL5RMwXJL9YWUU.jpg" /><figcaption>One way to guard the packages you use (source: <a href="https://boingboing.net/2017/05/05/review-guardians-of-the-galax.html">Guardians of the Galaxy 2</a>)</figcaption></figure><p>Do you use any 3rd party packages in your project?</p><p>Have you ever wondered what is the quality of those packages? What security vulnerabilities they might contain?</p><p>If not, maybe now it’s a good time to start thinking about this question. Each package you’re using could contain known vulnerability — but you don’t know. And you can’t fix something if you don’t know it’s broken.</p><p>So how can you find out about all those vulnerabilities and fix them on time? And how can you make sure that you stay secure over the time? How will you find out when a new vulnerability found on a package you’re using? Read along to find out.</p><h3>Using Snyk</h3><p>There are a few open source solutions like <a href="https://www.owasp.org/index.php/OWASP_Dependency_Track_Project">OWASP Dependency Track</a> that aim to solve this problem. Today I want to focus on a commercial product (that is free for open source projects) — <a href="https://snyk.io/">Snyk</a>.</p><p>Snyk is a great product that can be easily <a href="https://snyk.io/docs/github">integrated</a> into your pipeline to scan the packages you use in your project — both for security and licensing issues. It has built-in support for <a href="https://snyk.io/docs/notifications">notifications</a> (via email or Slack) when a new vulnerability was found in one of those packages. This might sound like a good solution, but it’s not perfect. Why?</p><p>Issues reported by Snyk, are just like any other production issues: indications of an issue that happens just now in production. And like any other production issue, the relevant person whose on-call should receive an alert, and fix it. This is why it should be reported by the same monitoring tools that are already in use. This will also allow us to ensure that everyone will treat this issue as a production issue, instead of missing or ignoring it accidentally.</p><h3>Integrating Snyk with Icinga2</h3><p><a href="https://www.icinga.com/">Icinga2</a> is a free and open source monitoring solution. Icinga is highly extensible — which mean I can use it to monitor issues reported by Snyk. I’m focusing on Icinga because this is we’re <a href="https://blog.solutotlv.com/distributed-monitoring-for-devops-teams-using-icinga-and-puppet/">using</a> at <a href="https://blog.solutotlv.com/">Soluto</a>, where I work. If you’re using something else, like Prometheus Alert Manager, the same idea can be applied — the implementation will be different.</p><p>In order to integrate Snyk with Icinga, all that is required is writing a <a href="https://www.icinga.com/docs/icinga2/latest/doc/05-service-monitoring/#create-a-new-plugin">check plugin</a> — which is just a script, running on Icinga. The script will use <a href="https://snyk.docs.apiary.io/">Snyk API</a> to <a href="https://snyk.docs.apiary.io/#reference/projects/project-issues/list-all-issues">list the issues</a> of a given project. If the project has no issues — the scritp will return ok (exit code 0), either wise— warning (exit code 1):</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d9d33951ed2294aef950ba1541ac2aa8/href">https://medium.com/media/d9d33951ed2294aef950ba1541ac2aa8/href</a></iframe><p>The code is very simple. To use it, follow the <a href="https://snyk.docs.apiary.io/#introduction/authorization">documentation</a> to find your API KEY, and then run it:</p><pre>./check.rb -k &lt;Snyk&#39;s API Key&gt; -o &lt;The organization ID containing the project&gt; -p &lt;The requested project to check&gt;</pre><p>To add this code to your Icinga instance, upload it to somewhere on your server. Than, follow the documentation for creating a new <a href="https://www.icinga.com/docs/icinga2/latest/doc/05-service-monitoring/#checkcommand-definition">check command</a>. Now you can start using this check command everywhere!</p><h3>Wrapping Up</h3><p>Now that you know how to use packages securely, it’s time to apply it. For each project you have you need to (after creating an account on Snyk, of course):</p><ul><li>Create a new project on Snyk, and scan all the packages</li><li>Triage the issues found by Snyk</li><li>Add the check command to the relevant host on Icinga, to monitor this project on Snyk</li></ul><p>This is a long process, especially if you have a lot of projects (and when using micro-services or FASS, there could be hundreds of projects). And this effort that should be done by the developers, who own those projects.</p><p>This is a tedious and annoying process, but (as I hope you now understand) also a very important one. The good part — once you complete this process for a project, you can rest assured. Snyk and Icinga will watch your back and guard you against using packages with known vulnerabilities, at least in this project.</p><p>So, What are you waiting for? A journey of a thousand miles begins with a single step. Go ahead, choose one project, and try this process out. You might be surprised with what you will find. I know I was.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=667798cac6cc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Price of Source Code Obfuscation]]></title>
            <link>https://medium.com/@omerlh/the-price-of-source-code-obfuscation-6feadd89f98a?source=rss-b1e3822cf24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/6feadd89f98a</guid>
            <category><![CDATA[appsec]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[obfuscation]]></category>
            <dc:creator><![CDATA[Omer Levi Hevroni]]></dc:creator>
            <pubDate>Tue, 22 May 2018 18:30:25 GMT</pubDate>
            <atom:updated>2018-06-06T18:32:21.230Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Hidden Cost of Source Code Obfuscation</h3><p>Today I want to talk about source code obfuscation for Android applications. It is well known <a href="https://www.owasp.org/index.php/Mobile_Top_10_2016-M9-Reverse_Engineering">why it is important</a> and how it can be done using P<a href="https://medium.com/@maheshwar.ligade/enabling-proguard-for-android-98e2b19e90a4">roguard</a>. But what is the price of enabling obfuscation? How it affects your application? This is what I want to discuss today.</p><p>But why it is important to understand the price?</p><p>Think about the last time you went to shopping. When you try to decide if you want to purchase a specific product, one thing you need to consider is the price: Does the value this product gave me is bigger than it’s price? And the same question should be asked also for security controls. We, the security team, is responsible to help you, the developer (or the product managers), understand the value it can give you (what threats it can mitigate) and it’s price (how it can affect your software). By understanding both the value and the price, you can take the right decision — for you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*YcVbowBTuv6a6aPM.jpg" /><figcaption>Should you buy tomatoes? Check the price to decide (source: <a href="https://pixabay.com/en/grocery-store-supermarket-vegetable-2119702/">pixabay</a>)</figcaption></figure><p>Now that we understood why it the price is important, let’s go back to obfuscation. From my experience, there are three side effects:</p><ul><li>Introducing new bugs</li><li>Production debugging</li><li>Debug vs Release builds</li></ul><p>Let’s dive in into each one of those side effects, understand what it is and what we can do to handle it.</p><h3>1. Introducing new bugs</h3><p>The first side effect — enabling source code obfuscation can and will introduce new bugs. It happens because obfuscation changes your code - including changing classes/properties/functions names. This is good, as long as you don’t have code that uses classes/properties/functions names.</p><p>One example is serialization — because the serialization process is using (by default)the object properties names (see, for example, the <a href="https://github.com/google/gson/blob/master/UserGuide.md#TOC-Object-Examples">Gson</a> documentation). The Obfuscation process will change the properties names — which will change the serialized JSON accordingly. This could, for example, results in invalid JSON being sent to your server.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*z7QwWP-cOt6VRnZ5.png" /><figcaption>Your server, when receiving the obfuscated JSON (source: <a href="https://me.me/i/400-bad-request-made-on-imgur-none-20905841">me.me</a>)</figcaption></figure><p>Another example is code that uses <a href="https://en.wikipedia.org/wiki/Reflection_(computer_programming)">reflection</a>. Let say that your code is looking for a specific property foo on all the classes. This code will break when you enable obfuscation — because the property name has changed.</p><p>What can you do? Actually, good solutions exist, because this issue is so common. For example, you can exclude specific classes from being obfuscated (see this <a href="https://stackoverflow.com/questions/15476315/prevent-class-member-name-obfuscation-by-proguard">question</a> on Stack Overflow). Another option is to explicitly specify how to serialize the class (<a href="https://github.com/google/gson/blob/master/UserGuide.md#TOC-JSON-Field-Naming-Support">this</a> is the relevant Gson documentation). You still need to be aware to this issue and be prepared to have some extra work to handle it.</p><p>It also important to remember that this is an on-going process — each new class that is serialized, or new code that use reflection, could introduce this bug. You need to have a process to handle it (for example, code review question or static analysis) so you could easily solve them.</p><h3>2. Production Debugging</h3><p>When investigating a production crash, the only useful information you have is the exception that was thrown (what happened) and the <a href="https://en.wikipedia.org/wiki/Call_stack">call stack</a> (where it happened). This information is useful when the call stack contains meaningful methods names, but what happens when the code is obfuscated? All the classes and methods will have obfuscated names — resulted in a meaningless call stack. It will be very hard to understand what is a.b.t.1 and an exception was thrown there.</p><p>This issue is also common and there is a simple solution. ProGuard generates a <a href="https://developer.android.com/studio/build/shrink-code#decode-stack-trace">mapping file</a> that translates between the random names of classes, methods, and properties to their original names. By using this file, you could translate the obfuscated call stack and make it meaningful again.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/702/0*9I4BtDTGEmhY5ko3.jpg" /><figcaption>An alternative solution to the problem (source: <a href="https://www.reddit.com/r/ProgrammerHumor/comments/6ayz26/defensive_programming_done_right/">Reddit</a>)</figcaption></figure><p>That sounds simple, but there is some work to be done in order for this solution to work: First, You need to keep all the mapping files for all the versions that are currently in production. Those files should be kept relatively secure, because if a hacker get this file — the obfuscation is meaningless. Second, if you’re using an error reporting service (like <a href="https://www.bugsnag.com/">Bugsnag</a> or <a href="https://get.fabric.io/">Fabric</a>), you need to upload this file to there too. This adds some operational overhead that you should take into consideration.</p><h3>3. Release vs Debug build</h3><p>Those two side effects are related to the last side effect I wanted to discuss. The common practice is to enable obfuscation only on release build. Why? This is because of the difference between debug and release builds.</p><p>Debug build is what developers are using for their daily work. This build is focused on the developer experience — it needs to be fast, and easy to debug. Release build is focused on the user — they should work fast and secure. This is why obfuscation is done only in release build —an obfuscated code is a lot harder to debug (that was what the previous section was about). Also, obfuscation makes the build a bit slower.</p><p>The only problem — it creates a significant difference between the release and debug builds. Code obfuscation can and will introduce new bugs (this was the first issue I discussed). Enabling obfuscation only on release build means that those issues will be discovered really late — only when using the release build: by an end to end or acceptance tests — or, in the worst case, only on production.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/0*vFS7A2lNe1RXxJFi.jpg" /><figcaption>The result of debug vs release issues (source: <a href="https://imgflip.com/i/9mqg4">imgflip</a>)</figcaption></figure><p>This is a serious side effect. What makes it even worse is the fact that there is not a lot you can do to handle this issue. One option is enabling obfuscation also for debug builds, but it introduces other issues (like I discussed above).</p><h3>Wrapping Up</h3><p>Source code obfuscation is an important security control. When done correctly, it provides another layer of protection (of course, it should never be the only protection). But like any other security control, it comes with a price. Now you have a better understanding of the price, and you can take the right decision for you — based on the threat model of your application. There are situations when you don’t have a choice — for example, when you are required to comply with a specific regulation. Even in those situations, understanding the price could help you estimate what the required effort.</p><p>And one last word — <a href="https://www.owasp.org/index.php/Main_Page">OWASP</a> is here for your help. While working on enabling obfuscation on anAndroid application, I needed help. The <a href="https://www.owasp.org/index.php/OWASP_Mobile_Security_Testing_Guide">Mobile Testing Guide</a> and the people on the relevant <a href="https://owasp.slack.com/messages/C1M6ZVC6S">Slack channel</a> helped me a lot during the process. Don’t hesitate to ask for help when you need it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6feadd89f98a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Takeaway from DevSecCon Tel Aviv 2018]]></title>
            <link>https://medium.com/@omerlh/takeaway-from-devseccon-tel-aviv-2018-d51a5239b053?source=rss-b1e3822cf24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/d51a5239b053</guid>
            <category><![CDATA[devsecops]]></category>
            <category><![CDATA[appsec]]></category>
            <category><![CDATA[continuous-integration]]></category>
            <category><![CDATA[devseccon]]></category>
            <dc:creator><![CDATA[Omer Levi Hevroni]]></dc:creator>
            <pubDate>Tue, 08 May 2018 17:57:45 GMT</pubDate>
            <atom:updated>2018-05-08T18:06:56.978Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ss8sZOQcZwQ_V8Qa." /></figure><p>My main takeaway from DevSecCon Tel Aviv 2018 (you can find the full schedule <a href="https://www.devseccon.com/tel-aviv-2018/">here</a>):</p><ul><li>Security is like health service: This point is from the opening key note by <a href="https://twitter.com/pink_tangent">Lidia Giuliano</a>. We should thinking about security like we think about our doctor. Our doctor could explain about all the risks in smoking, and advice us to stop smoking — but the final decision is ours. And the same is also true for security. We should spent all the effort on explaining what is the risk, and gave the developers all the tools — but the final decision is theirs, not ours.</li><li>Value driven threat modelling: A talk by <a href="https://twitter.com/sec_tigger">Avi Douglen</a>. This threat modeling approach is focused on what value the specific feature should gave us, and by focusing on the value try to find the relevant threats. As Avi explained, all existing threat modeling approaches created for security persons, not for developers. This approach created for developers, to help them create valuable threat models. It was really interesting to hear about it, and I hope Avi will write a post about it soon :)</li><li>Using the CI/CD pipeline to improve application security. The CI/CD pipeline is a powerful tool you can use to improve security. On the panel dedicated to this subject (participant: Avi Douglen, Lidia Giuliano, <a href="https://twitter.com/shehackspurple">Tanya Janca</a> and myself), we talked about ideas like: security unit tests, breaking the build, regression tests, and dealing with legacy apps. On my session, I’ve talked about the various FOSS security tools you can add into your pipeline (slides are <a href="https://www.slideshare.net/SolutoTLV/security-testing-for-containerized-applications">here</a>).</li><li>Practical information, like <a href="https://www.puresec.io/blog/serverless-top-10-released">top 10 serverless security risks</a> by <a href="https://twitter.com/Shulik">Avi Shulman</a>, or SSDLC for containers (checkout this <a href="https://twitter.com/omerlh/status/993397411228811264">slide</a> for security tips) by <a href="https://www.devseccon.com/tel-aviv-2018/speaker/vitaly-davidoff/">Vitaly Davidoff</a>. <a href="https://twitter.com/grander">Danny Grander</a> had a great session discussing open source packages vulnerabilities, hope he’ll publish the slides soon :)</li></ul><p>Overall, it was a really good conference, and I’m already looking forward to DevSecCon Tel Aviv 2019.</p><p>How was your experience? What did you take out of it? I’m looking forward to hear!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d51a5239b053" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How To: Scripting OWASP Zap with JavaScript]]></title>
            <link>https://medium.com/@omerlh/how-to-scripting-owasp-zap-with-javascript-1c1898b1e7e0?source=rss-b1e3822cf24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/1c1898b1e7e0</guid>
            <category><![CDATA[scripting]]></category>
            <category><![CDATA[owasp]]></category>
            <category><![CDATA[zap]]></category>
            <category><![CDATA[continuous-integration]]></category>
            <dc:creator><![CDATA[Omer Levi Hevroni]]></dc:creator>
            <pubDate>Thu, 26 Apr 2018 08:17:27 GMT</pubDate>
            <atom:updated>2018-04-26T08:17:27.106Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/225/1*OeO8oEP3Yv3y0hSOj5UxYQ.png" /><figcaption>OWASP Zap</figcaption></figure><p><a href="https://github.com/zaproxy/zaproxy">OWASP Zap</a> is a great open source security tool. I’m use it mainly on the CI/CD pipeline, to build dynamic security testing easily (checkout this <a href="http://blog.solutotlv.com/dynamic-security-testing-made-easy/?utm_source=medium">post</a> to find out how).</p><p>Today I want to talk about Zap scripting mechanism, and how it allows you to easily extend it. In case you’re not familiar with the scripting mechanism, checkout those <a href="https://www.slideshare.net/psiinon/2017-devseccon-zap-scripting-workshop">slides</a>. The slides are from a workshop that covers Zap’s scripting mechanism, by one of Zap’s authors, Simon Bennetts.</p><h3>First Step: Writing the Script</h3><p>Obviously, this is the first thing we’ll need to do. The rule I’m going to write is a rule that detects anonymous request — requests without Authorization header. Authentication is important and critical security mechanism, and that why I want Zap to detect all those requests and report them. Later, the developers can looks on those URLs and decide what to do.</p><p>Writing the rule is simple (And thanks to Kingthorin from Zap’s team who <a href="https://github.com/zaproxy/zaproxy/issues/4602#issuecomment-382106798">wrote it</a>), here is the code:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f2f6f2f20ce475d0d5a99715654cdd2c/href">https://medium.com/media/f2f6f2f20ce475d0d5a99715654cdd2c/href</a></iframe><p>The script is a <a href="https://github.com/zaproxy/zap-core-help/wiki/HelpStartConceptsPscan">passive scan</a> rule, which means it can inspect the request and response, but not modify them. Let’s go quickly over the code to understand what it does:</p><ul><li>Line 24 get the Authorization header from the request.</li><li>Line 27 check that the header is not present and that the returned status code is 200. If the status code is not 200, it means that the server has rejected the anonymous requests. An improvement should be to check that the status code is not 401 or 403, which is related to authentication issues. Anyway, for first iteration this is good enough.</li><li>Line 29 raise an alert to Zap. As any other rule, the alert should contains many details so the developers could understand what is the issue, why it is an issue and how it can be fixed.</li></ul><p>Simple, right? The last challenges is writing tests for those rules, but this is something I’ll cover on another posts (when I actually have the time to work on testing :)).</p><h3>Second Step: Loading the Script into Zap</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/515/1*H0o4AkitP0-Ap4Vn6O24Pg.png" /><figcaption>The hard fact of using Docker</figcaption></figure><p>Loading the script using the GUI is relatively simple, and you can follow this <a href="https://github.com/zaproxy/zap-core-help/wiki/HelpAddonsScriptsScripts">guide</a> to find out how. I want to use Zap in the CI/CD pipeline, so GUI is not an option. With a lot of help from Zap’s team, I was able to find out how this could be done (see <a href="https://github.com/zaproxy/zaproxy/issues/4602#issuecomment-382106798">this</a> and <a href="https://github.com/zaproxy/zaproxy/issues/4626">this</a> issues). The first thing we need to do is to modify Zap’s config file so it will load and enable our script:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/00d053955716aeab0c0dd48241d1e905/href">https://medium.com/media/00d053955716aeab0c0dd48241d1e905/href</a></iframe><p>Add this section to the end of config.xml (find the full file <a href="https://github.com/zaproxy/zaproxy/blob/develop/src/xml/config.xml">here</a>). This section simply tell Zap’s to load our script and enable it. The next step is writing a custom Dockerfile that will load this file, and our script:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4f33d0c8fd2122fe4b4a515a2b63a470/href">https://medium.com/media/4f33d0c8fd2122fe4b4a515a2b63a470/href</a></iframe><p>Let’s see what happens here:</p><ul><li>Line 7 install and update a few addons</li><li>Line 9 copy the scripts folder with our scripts</li><li>Line 11 copy the config.xml file</li><li>Line 15 set permissions so Zap can read the configuration file</li><li>Line 19 launch Zap with all the required arguments, so users of this Docker images will not have to bother.</li></ul><p>To make sure Zap’s actually load the script, you can use this URL:</p><pre><a href="http://localhost:1234/JSON/script/view/listScripts/?zapapiformat=JSON&amp;formMethod=GET">http://localhost:1234/JSON/script/view/listScripts/?zapapiformat=JSON&amp;formMethod=GET</a></pre><p>If everything was done correctly, you should see the script you added. If you want to see a full working setup, check out this <a href="https://github.com/Soluto/owasp-zap-glue-ci-images">repo</a>. The repo contains the Dockerfile we’re using at <a href="http://solutotlv.com/">Soluto</a> to run Zap on our CI. I did all the changes described on this post on a branch, so you can also checkout the <a href="https://github.com/Soluto/owasp-zap-glue-ci-images/pull/1">pull request</a>.</p><h3>Conclusion</h3><p>Now you know how you can easily extend Zap using your favourite language (which can be JavaScript, Ruby, Python etc). This gave you another easy way to customize Zap to your needs. Go ahead and give it a try, I’m looking forward to hear about your experience!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1c1898b1e7e0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to simplify the deployment of containerized apps]]></title>
            <link>https://medium.com/free-code-camp/how-can-we-simplify-deployment-of-containarized-apps-a2effd01a662?source=rss-b1e3822cf24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/a2effd01a662</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[helm]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[continuous-deployment]]></category>
            <dc:creator><![CDATA[Omer Levi Hevroni]]></dc:creator>
            <pubDate>Mon, 16 Apr 2018 05:11:19 GMT</pubDate>
            <atom:updated>2018-04-23T22:33:47.561Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JsbjpBYQU1Dnucn63ZcDTA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/photos/l_VVd8nV3PE?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Ilze Lucero</a> on <a href="https://unsplash.com/search/photos/container?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>I asked myself this question when I started to learn <a href="https://kubernetes.io/">Kubernetes</a>: how can we simplify the deployment of containerized apps? At first look, deploying containerized apps seems pretty simple. All you need is a bunch of YAML files, and by using <a href="https://kubernetes.io/docs/reference/generated/kubectl/kubectl/">kubectl</a> (the Kubernetes command line utility), you’ll have your service up and running in your Kubernetes cluster.</p><p>But, Although deploying one app is an easy task, how do you deploy hundreds of apps? At <a href="https://www.solutotlv.com/">Soluto</a>, we have more than 100 live microservices and this number keeps growing. So as we started thinking about shifting workload to our Kubernetes cluster, we faced a few challenges:</p><p>First, Kubernetes deployment is actually more complex. There are many moving parts that you need to set up correctly: pod autoscaler, pod resources, ingress, and so on. Those parts require some experience with how Kubernetes works, and not setting it up correctly might cause issues in production. Ideally we’d have a way to simplify this, so developers can focus on writing their code and worry less about deployment.</p><p>Second, security is also a challenge. All services in production should have certain things, like Transport Layer Security (TLS). These are not necessarily complex things, but need to be taken care of nonetheless. We would like to pre-configure them so that any new deployment will be secured by default.</p><h3>Finding a solution</h3><p>To solve these challenges and speed up and ease the adoption process, we looked for a way to create a template for Kubernetes. Something that any developer would be able to use, and would require just a few parameters (for example, the Docker image of the service) to get the service up and running in production.</p><p>On the other hand, we needed to be careful not to hide too much — developers must be able to understand what’s going on so they can handle production issues. We had to find the right level of abstraction that makes it easier to deploy to Kubernetes, without hiding too much detail.</p><p>With that in mind, we started to look for a solution. After trying a few things, we found <a href="https://helm.sh/">Helm</a>. Helm is a package manager for Kubernetes.You can use it to install any app on your cluster, and Helm will take care of getting all the required configuration files and installing them on your cluster. Helm also support updating deployments, rollbacks, and many other cool features. Each Helm package is called a “Chart”, and the charts are stored in a repository. With helm, installing <a href="https://github.com/kubernetes/charts/tree/master/stable/mongodb">Mongo</a>, for instance, is as easy as helm install stable/mongodb.</p><p>Sound like an excellent solution! We can define a chart for each type of service — like one for all our web APIs, which will handle things like load balancer and TLS — and the developer simply needs to specify the required parameters using Helm’s configuration files.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QzKmrPtCm5SvCklDccppkQ.png" /><figcaption>Me and my teammate, when we found Helm</figcaption></figure><h3>Helm: Let’s see how it’s done</h3><p>In order to use Helm, we first need to <a href="https://docs.helm.sh/using_helm/#installing-helm">install</a> it. Helm has two components: Helm client running on your computer, and Tiller, a server-side component running on your cluster. Then, we need to create the chart by using this simple Helm CLI command: helm create web-api</p><p>After running this command, you’ll notice the creation of a new folder named “web-api”. Within this folder, you’ll find all the familiar Kubernetes configuration files: deployment, service, ingress, and so on. Now it’s time to customize a bit: we can add a <a href="https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/">horizontal pod autoscaler</a>, define the default resources the pod requires, and of course, enable TLS by default.</p><p>Everything is highly customizable based on the <a href="https://docs.helm.sh/chart_template_guide/">Go templating mechanism</a>. So anything we add can be overridden later by the developer, in case the default configuration doesn’t work as needed.</p><p>So now we have a chart — but how can we consume it? The chart has to exist in a <a href="https://github.com/kubernetes/helm/blob/master/docs/chart_repository.md">Helm repository</a>, which is basically a server with a few Zip archives (which are all the charts in the repository) and one index file that is consumed by the CLI. You can manually set up your repo using any storage service like Azure Blob or AWS S3, but the simplest option is <a href="https://github.com/kubernetes-helm/chartmuseum">Chart Museum</a>.</p><p>Chart museum is a Helm repository with a CRUD API to manage your charts. It supports basic authentication so you can restrict who can push new charts to your Helm repository. Helm doesn’t supply any museum-as-a-service solution, so you’re gonna have to roll your own. But it’s dead simple — <a href="https://hub.docker.com/r/chartmuseum/chartmuseum/">simply use its docker image.</a></p><p>Now we can build a CI/CD pipeline for our web-api chart, to ease the process of modifying it:</p><ul><li>Run some kind of tests, to make sure that the new version is not broken. I’ll discuss how in the next paragraph.</li><li>Pack the new chart, using Helm CLI.</li><li>Push the new package to our Chart Museum instance, using Chart Museum’s API.</li></ul><h3>Testing it out</h3><p>Now our chart is ready to be used by developers! But wait… how can we know that the chart actually works? And how can we make sure it will continue to work? This is why we need to write tests for our chart (like we write for anything else).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/475/1*alAM_ESQQt64XthNjmbYiQ.png" /></figure><p>There are basically two things we want to test.</p><ol><li>We want to test our template — for example, if an ingress is supposed to exist with a TLS and specific rules (defined by the developer), we should test the generated template and make sure the ingress was created correctly.</li><li>We want to test that the files are valid Kubernetes configurations and that they work as expected.</li></ol><p>Testing the first thing is relatively simple — check out this <a href="https://github.com/omerlh/helm-chart-tests-demo">sample repo</a> to see just how simple it is.</p><p>This allows us to test the generated Kubernetes files, by using <a href="https://github.com/garethr/kubetest">kubetest</a>. This is great, but can be complex and messy, especially when having a lot of branching in your template files.</p><p>A better solution is required — one that will allow us to do unit testing for the templates, without generating Kubernetes files. This wasn’t a problem until recently when we started to have a lot of branching in our templates, and we’re now looking for options.</p><p>The second thing — testing that Kubernetes files are valid — is a bit more tricky. For now, at Soluto we’re using Helm’s version mechanism: each chart has a version, and all of our services will use the latest stable version. When a new chart version is pushed, we can test this version on a specific service. If it works correctly, update the rest of the services. Another option is to test that using minikube, but it was too complex for our needs.</p><h3>Finally: Deploying!</h3><p>So now we have a CI/CD pipeline for our Helm charts, and we have prepared a Helm chart that the developers can use. Now, when a new developer wants to deploy a new service to production, all they have to do is:</p><p>1. Add our repository to their local Helm using helm repo add chartmuseum http://&lt;chart-museum-url&gt;<br>2. Create a new Helm config file and specify the required parameters (for example, docker image of the service)<br>3. Run helm upgrade —install &lt;service-name&gt; chartmusuem/web-api -f&lt;path_to_config_file&gt; and that’s it. The service is alive.</p><p>And to make it even easier to understand, I’ve created a sample <a href="https://github.com/Soluto/kubernetes-deployment-demo">repository</a>. The repository contains all the things that I’ve discussed in this blog post: a generic chart for a web app that can be deployed with this chart and chart museum. Check it out to better understand what’s going on — and there is even a walkthrough to help you get started.</p><p>Thank you for reading along. If you have any questions, or you need help getting started with Helm, feel free to reach out either via the comments here or via <a href="https://twitter.com/intent/tweet?text=.%20%40omerlh%2C%20I%20have%20a%20question%20about%20%40Helm&amp;via=SolutoEng">Twitter</a>.</p><p>Happy Helming!</p><p>Originally posted on <a href="https://blog.solutotlv.com/?utm_source=medium">Soluto’s Blog</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a2effd01a662" width="1" height="1" alt=""><hr><p><a href="https://medium.com/free-code-camp/how-can-we-simplify-deployment-of-containarized-apps-a2effd01a662">How to simplify the deployment of containerized apps</a> was originally published in <a href="https://medium.com/free-code-camp">We’ve moved to freeCodeCamp.org/news</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Can Kubernetes Deployment be fun and simple?]]></title>
            <link>https://medium.com/@omerlh/can-kubernetes-deployment-be-fun-and-simple-6d855bdf56d0?source=rss-b1e3822cf24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/6d855bdf56d0</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[helm]]></category>
            <category><![CDATA[helm-chart]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Omer Levi Hevroni]]></dc:creator>
            <pubDate>Tue, 10 Apr 2018 08:05:20 GMT</pubDate>
            <atom:updated>2020-02-12T09:46:36.573Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rh-f7djGcYsUCvyp7EFsYQ.png" /></figure><p>Short answer: YES ( <a href="https://blog.solutotlv.com/deploying-kubernetes-like-a-pro/#finally-deploying">scroll</a> to end to find out, or check out the <a href="https://github.com/Soluto/kubernetes-deployment-demo">sample repo</a>).</p><p>Long answer: Read along to find out!</p><p>Kubernetes deployment seems pretty simple: all you need is just a bunch of YAML files, and by using (the Kubernetes command line utility) you’ll have your service up and running in your Kubernetes cluster.</p><p>Although deploying one service is an easy task, how do you deploy hundreds of microservices? At Soluto, we have more than 100 live microservices and the number keeps growing — so as we started thinking about shifting workload to our Kubernetes cluster, we faced a few challenges:</p><p>Kubernetes deployment is complex, and there are many moving parts that you need to set up correctly: pod autoscaler, pod resources, ingress, etc. Those parts require some experience with how Kubernetes works, and not setting it up correctly might cause issues in production. Ideally, we’d have a way to simplify this, so developers can focus on writing their code and worry less about deployment.</p><p>Security is another challenge. All services in production should have certain things, like Transport Layer Security (TLS), which are not necessarily complex but need to be taken care of nonetheless. We would like to pre-configure them so that any new deployment will be secured by default.</p><h3>Finding a solution</h3><p>To solve these challenges and speed up and ease the adoption process, we looked for a way to create a template for Kubernetes. Something that any developer would be able to use, and would require just a few parameters (e.g. the Docker image of the service) to get the service up and running in production.</p><p>On the other hand, we needed to be careful not to hide too much — developers must be able to understand what’s going on so they can handle production issues. We had to find the right level of abstraction that makes it easier to deploy to Kubernetes, without hiding too much detail.</p><p>With that in mind, we started to look for a solution. After trying a few things, we found <a href="https://helm.sh/">Helm</a>. Helm is a package manager for Kubernetes. You can use it to install any app on your cluster, and Helm will take care of getting all the required configuration files and installing them on your cluster. Helm also support updating deployments, rollbacks, and many other cool features. Each Helm package is called a “Chart”, and the charts are stored in a repository. With helm, installing <a href="https://github.com/kubernetes/charts/tree/master/stable/mongodb">Mongo</a>, for instance, is as easy as helm install stable/mongodb.</p><p>Sound like an excellent solution! We can define a chart for each type of service — like one for all our web APIs, which will handle things like load balancer and TLS — and the developer simply needs to specify the required parameters using Helm’s configuration files.</p><h3>Helm: Let’s see how it’s done</h3><p>In order to use Helm, we first need to <a href="https://docs.helm.sh/using_helm/#installing-helm">install</a> it (Helm has two components — Helm client running on your computer and Tiller, a server-side component running on your cluster). Then, we need to create the chart, by simply using this Helm CLI command: helm create web-api</p><p>After running this command, you’ll notice the creation of a new folder named “web-api”. Within this folder you’ll find all the familiar Kubernetes configuration files: deployment, service, ingress, etc.. Now it’s time to customize a bit: we can add a <a href="https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/">horizontal pod autoscaler</a>, define the default resources the pod requires, and of course, enable TLS by default. Everything is highly customizable based on the <a href="https://docs.helm.sh/chart_template_guide/">Go templating mechanism</a>, so anything we add can be overridden later by the developer, in case the default configuration doesn’t work as needed.</p><p>So now we have a chart — but how can we consume it? The chart has to exist in a <a href="https://github.com/kubernetes/helm/blob/master/docs/chart_repository.md">Helm repository</a>, which is basically a server with a few Zip archives (which are all the charts in the repository) and one index file that is consumed by the CLI. You can manually set up your repo using any storage service like Azure Blob or AWS S3, but the simplest option is <a href="https://github.com/kubernetes-helm/chartmuseum">Chart Museum</a>.</p><p>Chart museum is a Helm repository with a CRUD API to manage your charts. It supports basic authentication so you can restrict who can push new charts to your Helm repository. Helm doesn’t supply any museum-as-a-service solution, so you’re gonna have to roll your own — but it’s dead simple — <a href="https://hub.docker.com/r/chartmuseum/chartmuseum/">simply by using its docker image.</a></p><p>Now we can build a CI/CD pipeline for our web-API chart, to ease the process of modifying it:<br> — Run some kind of tests, to make sure that the new version is not broken. I’ll discuss how in the next paragraph.<br> — Pack the new chart, using Helm CLI.<br> — Push the new package to our Chart Museum instance, using Chart Museum’s API.</p><h3>Testing it out</h3><p>Now our chart is ready to be used by developers! But wait… how can we know that the chart actually works? And how can we make sure it will continue to work? This is why we need to test our chart, and there are basically two things we want to test.</p><p>1) We want to test our template — for example, if an ingress is supposed to exist with a TLS and specific rules (defined by the developer), we should test the generated template and make sure the ingress was created correctly. 2) We want to test that the files are valid Kubernetes configurations and that they work as expected.</p><p>Testing the first thing is relatively simple — check out this <a href="https://github.com/omerlh/helm-chart-tests-demo">sample repo</a> to see just how simple it is. This allows us to test the generated Kubernetes files, by using. This is great but can be complex and messy, especially when having a lot of branching in your template files. A better solution is required — that will allow us to do unit testing for the templates, without generating Kubernetes files. This wasn’t a problem until recently when we started to have a lot of branching in our templates and we’re now looking for options.</p><p>The second thing, testing that Kubernetes files are valid, is a bit more tricky. For now, at Soluto we’re using Helm’s version mechanism: each chart has a version, and all of our services will use the latest stable version. When a new chart version is pushed, we can test this version on a specific service. If it works correctly, update the rest of the services. Another option is to test that using minikube, but it was too complex for our needs.</p><h3>Finally: Deploying!</h3><p>So now we have a CI/CD pipeline for our Helm charts, and we have prepared a Helm chart that the developers can use. Now, when a new developer wants to deploy a new service to production, all they have to do is:</p><p>1. Add our repository to their local Helm using helm repo add chartmuseum http://&lt;chart-museum-url&gt;<br> 2. Create a new Helm config file and specify the required parameters (e.g. docker image of the service)<br> 3. Run helm upgrade -install &lt;service-name&gt; chartmusuem/web-api -f &lt;path_to_config_file&gt; and that&#39;s it - the service is alive.</p><p>And to make it even easier to understand, I’ve created a sample <a href="https://github.com/Soluto/kubernetes-deployment-demo">repository</a>. The repository contains all the things that I’ve discussed in this blog post: A generic chart for a web app, a simple app that can be deployed with this chart and chart museum. Check it out to better understand what’s going on — just follow the walkthrough in the repo.</p><p>Thank you for reading along. If you have any questions, or you need help getting started with Helm, feel free to reach out either via the comments here or via <a href="https://twitter.com/intent/tweet?text=.%20%40omerlh%2C%20I%20have%20a%20question%20about%20%40Helm&amp;via=SolutoEng">Twitter</a>.<br> Happy Helming!</p><p>Found this interesting? Share!</p><p>By Omer Levi Hevroni</p><p><em>Originally published at </em><a href="https://blog.solutotlv.com/deploying-kubernetes-like-a-pro/"><em>https://blog.solutotlv.com</em></a><em> on April 10, 2018.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6d855bdf56d0" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>