<?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 Ron Izraeli on Medium]]></title>
        <description><![CDATA[Stories by Ron Izraeli on Medium]]></description>
        <link>https://medium.com/@izra.ron?source=rss-809715d6613a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*YyT7OdRFEgw2kZ5O-yxbsQ.jpeg</url>
            <title>Stories by Ron Izraeli on Medium</title>
            <link>https://medium.com/@izra.ron?source=rss-809715d6613a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 17:38:42 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@izra.ron/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[Do you know how your SCA scanner works?]]></title>
            <link>https://medium.com/@izra.ron/do-you-know-how-your-sca-scanner-works-7205506c5606?source=rss-809715d6613a------2</link>
            <guid isPermaLink="false">https://medium.com/p/7205506c5606</guid>
            <category><![CDATA[supply-chain-security]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[appsec]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[application-security]]></category>
            <dc:creator><![CDATA[Ron Izraeli]]></dc:creator>
            <pubDate>Fri, 31 Jan 2025 09:02:53 GMT</pubDate>
            <atom:updated>2025-01-31T09:02:53.749Z</atom:updated>
            <content:encoded><![CDATA[<p>Software Composition Analysis (SCA) tools are essential for identifying and managing open-source components and their vulnerabilities within your software projects. As the complexity of modern applications grows, so does the need for robust SCA solutions. However, not all SCA scanners are created equal. Depending on your use case, integration requirements, and the level of accuracy you need, different types of SCA scanners may be more suitable for your workflows.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qwNgrUc3VL2SP7hZY3-kCA.png" /></figure><p>We’ll explore the two primary types of SCA scanners—dependency file and filesystem scanners—along with their advantages, disadvantages, and sub-types. By the end, you’ll better understand which SCA scanner type best fits your needs.</p><h4>Dependency File Scanners</h4><p>Dependency file scanners analyze package manager files such as package.json (Node.js), pom.xml (Java), requirements.txt (Python), or lock files like yarn.lock or Gemfile.lock. These files list a project’s direct and sometimes transitive dependencies.</p><p><strong>Advantages</strong></p><ul><li><strong>Easy and Fast to Integrate</strong>: Dependency file scanners are straightforward to set up and can be integrated into CI/CD pipelines with minimal effort. They are ideal for teams looking for a quick way to start scanning their projects.</li><li><strong>Lightweight</strong>: Since they only analyze dependency files, these scanners are typically fast and require fewer resources.</li></ul><p><strong>Disadvantages</strong></p><ul><li><strong>Inaccurate Results</strong>: Dependency file scanners often struggle with transitive dependencies (dependencies of dependencies). They may not accurately reflect the versions of packages that will be installed, leading to false positives or negatives.</li><li><strong>Limited Scope</strong>: These scanners cannot detect packages manually added to the project or installed outside the dependency management system.</li></ul><p><strong>When to Use</strong><br>Dependency file scanners are best suited for teams prioritizing speed and simplicity over accuracy. They are a good starting point for essential dependency management but may not be sufficient for comprehensive security analysis.</p><h4>Filesystem Scanners</h4><p>Filesystem scanners analyze the actual files and directories in your project or host, including installed packages, binaries, and other artifacts. This type of scanner provides a more comprehensive view of the software (or OS) composition.</p><p><strong>Advantages</strong></p><ul><li><strong>Complete Visibility</strong>: Filesystem scanners can detect all packages present in the project, including those not listed in dependency files. This makes them more accurate for identifying vulnerabilities.</li><li><strong>Flexible Integration</strong>: They can be integrated at various stages of the development lifecycle, such as during local development, CI/CD pipelines, or post-deployment.</li></ul><p><strong>Disadvantages</strong></p><ul><li><strong>Complex Integration: </strong>Filesystem scanners require a deeper understanding of when and where to integrate them (which phase). For example, scanning too early in the pipeline might miss packages installed later.</li><li><strong>Irrelevant Packages</strong>: These scanners might pick up pipeline-related packages or dependencies that are not part of the final product, leading to noise in the results.</li><li><strong>Limited Scope in Pipelines: </strong>If the scanner is configured to scan only the source code folder, packages installed outside this directory might be missing.</li></ul><p><strong>When to Use</strong><br>Filesystem scanners are ideal for teams that need high accuracy and are willing to invest time in proper integration. They are handy for complex projects with multiple layers of dependencies.</p><h3>Sub-Types of Filesystem Scanners</h3><h4><strong>Docker Scanners</strong></h4><p>Docker scanners are specialized filesystem scanners that analyze container images. They provide insights into the packages and vulnerabilities present in the final production image.</p><p><strong>Advantages</strong></p><ul><li><strong>Production Accuracy</strong>: Scanning a Docker image ensures that the results match what your customers will see if they scan the same image. This is critical for identifying real-world risks.</li><li><strong>Comprehensive Analysis</strong>: Docker scanners can detect packages installed at any image layer, providing a complete picture of the container’s composition.</li></ul><p><strong>Disadvantages</strong>:</p><ul><li><strong>Missed Build-Time Packages</strong>: The scanner might miss packages used during the build phase if your build process bundles dependencies into a new artifact (e.g., a compiled binary or script) — a risk for supply chain attack.</li><li><strong>Resource-Intensive</strong>: Scanning large Docker images can be time-consuming and resource-heavy.</li></ul><p><strong>When to Use</strong><br>Docker scanners are essential for teams that deploy applications using containers. They are particularly valuable for ensuring the security of production environments.</p><h4>Package Manager Wrappers</h4><p>Package manager wrappers are another sub-type of filesystem scanners that hook into package managers (e.g., npm, pip, maven) during their execution of pull or pull commands (pull, install, push, publish, etc.).</p><p><strong>Advantages</strong></p><ul><li><strong>High Accuracy</strong>: These scanners see all packages downloaded and installed by the package manager, including transitive dependencies. This makes them one of the most accurate types of SCA tools.</li><li><strong>Real-Time Analysis</strong>: These scanners can provide real-time feedback during development by integrating directly with the package manager.</li></ul><p><strong>Disadvantages</strong></p><ul><li><strong>Complex Integration</strong>: Setting up package manager wrappers can be challenging, especially in projects with custom-build processes or multiple package managers.</li><li><strong>Limited to Supported Package Managers</strong>: These scanners are only effective for the package managers they support, which might limit their applicability in polyglot environments.</li></ul><p><strong>When to Use</strong><br>Package manager wrappers are ideal for teams that prioritize accuracy and are comfortable with more complex integrations. They are handy for projects with well-defined package management workflows.</p><h3>Combining Both Types</h3><p>Many modern SCA scanners combine dependency file and filesystem scanning capabilities to provide a balanced approach. For example, a scanner might start with a quick dependency file analysis and perform a deeper filesystem scan for more accurate results. This hybrid approach offers the best of both worlds: speed and accuracy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iF4UhAoKmAM721nYMjhqnQ.png" /></figure><h3>Conclusion</h3><p>Choosing the right SCA scanner depends on your specific needs, project complexity, and integration capabilities. Dependency file scanners are quick and easy to use but may lack accuracy, while filesystem scanners provide comprehensive insights at the cost of more complex integration. Sub-types like Docker scanners and package manager wrappers further refine the scanning process, offering specialized capabilities for containerized environments and accurate dependency tracking.</p><p>Understanding these differences is crucial for implementing effective software composition analysis. By selecting the right SCA scanner type, you can ensure that your applications are secure, compliant, and free from vulnerabilities introduced by open-source dependencies, as well as, and no less important, reduce the dev-sec friction.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7205506c5606" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Customer is Always Right?]]></title>
            <link>https://medium.com/@izra.ron/the-customer-is-always-right-ea7c7ad61bb0?source=rss-809715d6613a------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea7c7ad61bb0</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Ron Izraeli]]></dc:creator>
            <pubDate>Mon, 02 Dec 2024 22:16:28 GMT</pubDate>
            <atom:updated>2024-12-03T09:48:24.627Z</atom:updated>
            <content:encoded><![CDATA[<p>The phrase &quot;the customer is always right&quot; was popularized by early 20th-century retailers, to ensure customer satisfaction and build trust in the brand during a time when consumer protection laws were weak. The idea was meant to empower customers and create a service-driven culture. However, it has also been criticized over the years, with some arguing that it can lead to unreasonable demands and place undue pressure on employees.</p><p>One humorous twist is that many in the service industry joke that the phrase should be, &quot;The customer is always right… except when they’re wrong,&quot; reflecting the tension between providing great service and maintaining boundaries with difficult customers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Oyso-EomF1yJC_K4dQx9eQ.jpeg" /></figure><h3>But what about when collecting requirements for software products?</h3><p>Well, I’m not going to challenge the slogan. However, like the rest of us, human beings, customers often do know what they want BUT might communicate the requirements wrong.</p><p>Tech customers even tend to increase the challenge be offering a solution (my favorite) without a the comprehensive understanding or sharing the underlying requirements.</p><p>If you are a software developer or a product manager collecting requirements, you should always scratch the surface of what comes to you as “requirements”. In many cases, the description holds a much bigger problem or even a different one than the customer was able to describe.</p><blockquote><strong>Make sure you understand</strong> not (just) what the customer asks <strong>but what is the actual need so you could suggest the best solutions</strong></blockquote><p>In software development, the phrase &quot;the customer is always right&quot; can be misleading, as customers may not always understand the technical limitations or the best solutions for their needs. Rather than simply following customer’s requests, it’s crucial for teams to analyze and challenge requirements to deliver a product that truly solves the underlying problem or business need.</p><p>Consider this: A customer complains that a system is &quot;too slow.&quot; On the surface, the request may seem straightforward—optimize the software for speed. But upon deeper analysis, the actual issue could lie in a convoluted workflow or a misunderstanding of the tool&#39;s purpose. In cases like this, simply following the customer&#39;s request might fail to solve the root problem and could even exacerbate it.</p><figure><img alt="Why is it not working?" src="https://cdn-images-1.medium.com/max/1024/1*bggJABd8FlL-FOJpjgT9GA.jpeg" /></figure><p>Understanding and addressing the true problem is critical for delivering best solutions. This often requires balancing customer feedback with professional expertise, identifying underlying needs, and providing solutions that may differ from what the customer initially envisioned.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ea7c7ad61bb0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How did we seamlessly integrated JFrog CLI into our GitLab CI pipelines]]></title>
            <link>https://medium.com/@izra.ron/how-did-we-seamlessly-integrated-jfrog-cli-into-our-gitlab-ci-pipelines-52fd1d6e3119?source=rss-809715d6613a------2</link>
            <guid isPermaLink="false">https://medium.com/p/52fd1d6e3119</guid>
            <category><![CDATA[jfrog]]></category>
            <category><![CDATA[gitlab]]></category>
            <category><![CDATA[devsecops]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[supply-chain]]></category>
            <dc:creator><![CDATA[Ron Izraeli]]></dc:creator>
            <pubDate>Sun, 05 Mar 2023 10:41:56 GMT</pubDate>
            <atom:updated>2023-08-03T06:40:03.127Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0Yp--Le_SssMprneMxLfXw.png" /><figcaption>GitLab in the swamp (created with Midjourney)</figcaption></figure><p>In today’s fast-paced and ever-changing technological landscape, software development teams are constantly pressured to deliver high-quality code quickly and efficiently. To address that challenge, many developers and companies incorporate CI/CD pipelines into their SDLC. The GitLab solution consolidates the version control and the CI/CD pipeline in a single interface making it a popular solution. However, one of the biggest challenges the SDLC is facing evolves around the supply chain security posture throughout the building, testing, packaging, and deploying securely and reliably. This is where the integration of JFrog CLI into GitLab CI/CD pipelines comes into play. By leveraging the power of JFrog’s industry-leading binary repository manager and the flexibility of GitLab’s continuous integration and deployment platform, teams can streamline their software delivery process and achieve true Dev-Sec-Ops success. So, if you’re ready to take your software development to the next level, buckle up and join us on this journey as we explore how we integrated JFrog CLI into our GitLab CI pipelines.</p><p>We were seeking to <strong>improve our dependencies&#39; security posture </strong>and conduct a detailed <strong>composition analysis. </strong>We had previous tools integrated to our pipelines, however, the notion of <strong>consolidating both tools and visibility across our supply chain</strong> has great advantages. Since we already had been using JFrog Artifactory and Xray, it was easy for us to address our challenge with JFrog Build integration using JFrog CLI.</p><p>While JFrog provided best practice <a href="https://github.com/jfrog/gitlab-templates">examples and templates</a>, we quickly realized that implementing them across hundreds of projects was <strong>not a straightforward task</strong>.</p><p><a href="https://www.linkedin.com/posts/eyal-ben-moshe-63394a105_complete-your-software-supply-chain-with-activity-7036057899395072000-ix1D?utm_source=share&amp;utm_medium=member_desktop">Eyal Ben Moshe on LinkedIn: Complete your Software Supply Chain with GitLab CI/CD and JFrog</a></p><p>Here is an example of building npm according to JFrog’s best practice template →</p><pre>default:<br>  image: node:16<br><br>include:<br>  - remote: &quot;https://releases.jfrog.io/artifactory/jfrog-cli/gitlab/.setup-jfrog.yml&quot;<br>jfrog-npm-build:<br>  script:<br>    - !reference [.setup_jfrog, script]<br><br>    # Configure JFrog Artifactory repositories<br>    - jf npmc --repo-resolve $ARTIFACTORY_VIRTUAL_REPO --repo-deploy $ARTIFACTORY_LOCAL_REPO<br><br>    # Resolve dependencies from JFrog Artifactory<br>    - jf npm install<br><br>    # Deploy *.tar.gz to JFrog Artifactory<br>    - jf npm publish<br><br>    # Publish build-info to JFrog Artifactory<br>    - jf rt build-publish<br><br>  after_script:<br>    # Cleanup<br>    - !reference [.cleanup_jfrog, script]</pre><p>The challenges we came across are:</p><h4><strong>1# Effort</strong></h4><p>Adding the ‘jf’ prefix to tens or hundreds of project’s .gitlab-ci.yml files is a time-consuming effort — hence we are not likely to get the corporation of Dev and DevOps teams to implement.</p><h4><strong>2# Tight Coupling</strong></h4><p>Adding the ‘jf’ prefix creates a coupling that could potentially cause problems if we ever decided to remove or change it.</p><blockquote><em>First make the change easy, then make the easy change. </em>Kent Beck</blockquote><p>To address these challenges, we came up with a more sophisticated solution to reduce friction. We used GitLab CI’s template feature to create a generic template that included the JFrog CLI commands. This allowed us to avoid duplicating the same commands in every project’s pipeline, significantly reducing the effort required to integrate JFrog CLI.</p><p>We created a template so other project pipelines can easily consume it. common/templates/.ci-cd.yml →</p><pre>variables:<br>  ARTIFACTORY_BASE: https://artifactory.mycompany.com<br>  JFROG_CLI_BUILD_NAME: $CI_PROJECT_NAME.$CI_BUILD_REF_NAME<br>  JFROG_CLI_BUILD_NUMBER: $CI_PIPELINE_ID<br>  JFROG_CLI_BUILD_URL: $CI_JOB_URL<br>  JFROG_CLI_TEMP_DIR: $CI_PROJECT_DIR/build-info<br><br>.artifactory-base:<br><br>  before_script:<br><br>    # Install JFrog CLI<br>    - curl -v &gt;/dev/null 2&gt;&amp;1 || wget -q -O - $ARTIFACTORY_BASE/artifactory/generic/jfrog-cli/install-cli.sh | sh<br>    - jf -v &gt;/dev/null 2&gt;&amp;1 || curl -sS $ARTIFACTORY_BASE/artifactory/generic/jfrog-cli/install-cli.sh | sh<br>    <br>    # Create server ID<br>    - jf config add myartifactory --url $ARTIFACTORY_BASE --access-token=$JF_ACCESS_TOKEN<br>    <br>    # Configure JFrog Artifactory repositories<br>    #  Configure the following variables with the names of npm repositories in JFrog Artifactory:<br>    #  &#39;ARTIFACTORY_VIRTUAL_REPO&#39;, and &#39;ARTIFACTORY_LOCAL_REPO&#39;.<br>    - jf npm-config --repo-deploy=$ARTIFACTORY_VIRTUAL_REPO --repo-resolve=$ARTIFACTORY_LOCAL_REPO<br>    <br>    # Replace npm and docker commands with jf wrappers<br>    - mkdir -p /wrapper<br>    - echo &#39;#!/bin/sh&#39; &gt; /wrapper/npm &amp;&amp; echo &quot;PATH=\&quot;${PATH}\&quot;&quot; &gt;&gt; /wrapper/npm &amp;&amp; echo &#39;jf npm $@&#39; &gt;&gt; /wrapper/npm &amp;&amp; chmod +x /wrapper/npm<br>    - echo &#39;#!/bin/sh&#39; &gt; /wrapper/docker &amp;&amp; echo &quot;PATH=\&quot;${PATH}\&quot;&quot; &gt;&gt; /wrapper/docker &amp;&amp; echo &#39;jf docker $@&#39; &gt;&gt; /wrapper/docker &amp;&amp; chmod +x /wrapper/docker<br>    - export PATH=&quot;/wrapper:${PATH}&quot;<br><br>  after_script:<br><br>    # Add enviroment variables to build-info<br>    - jf rt bce $JFROG_CLI_BUILD_NAME $JFROG_CLI_BUILD_NUMBER<br><br>    # Add information from git to build-info<br>    - jf rt bag $JFROG_CLI_BUILD_NAME $JFROG_CLI_BUILD_NUMBER<br><br>    # Publish build-info to JFrog Artifactory<br>    - jf rt bp $JFROG_CLI_BUILD_NAME $JFROG_CLI_BUILD_NUMBER</pre><p>The template aims to wrap the job’s script with before and after operations. Before, we provision the JF CLI and configuration. And after, we upload the collected build-info.</p><p>Now, developers can include it in their .gitlab-ci.yml (read the comments)</p><pre># make .ci-cd.yml template jobs available to use in your pipeline<br>include:<br>  - project: common/templates<br>    file: &#39;.ci-cd.yml&#39;<br>    ref: latest<br><br>variables:<br>  ARTIFACTORY_DOCKER_REPO: artifactory.mycompany.com/docker<br>...<br><br>build:<br>  image: $ARTIFACTORY_DOCKER_REPO/node:16<br>  stage: build<br>  extends: .artifactory-base # instruct your job to apply the template wrappers (before and after script)<br>  script:<br>    - npm ci<br>    - npm publish</pre><p>Continuing to a more complex scenario, where you want to share your build-info across various stages (read the comments)</p><pre>include:<br>  - project: common/templates<br>    file: &#39;.ci-cd.yml&#39;<br>    ref: latest<br><br>variables:<br>  ARTIFACTORY_DOCKER_REPO: artifactory.mycompany.com/docker<br>  DIND: $ARTIFACTORY_DOCKER_REPO/docker:dind<br>  DOCKER_IMAGE_NAME: $ARTIFACTORY_DOCKER_REPO/$CI_PROJECT_PATH:$CI_BUILD_ID-$CI_BUILD_REF_NAME<br><br>stages:<br>  - build<br>  - package<br><br>build:<br>  image: $ARTIFACTORY_DOCKER_REPO/node:16<br>  stage: build<br>  extends: .artifactory-base<br>  after_script: [] # Override template&#39;s after_script to prevent build-info publish so we can aggregate the next job<br>  script:<br>    - npm ci<br>    - npm run build<br>  artifacts:<br>    paths:<br>      - build<br>      - build-info # Share the build-info folder for the next job<br><br>package:<br>  image: $DIND<br>  stage: package<br>  extends: .artifactory-base<br>  services:<br>    - name: $DIND<br>      alias: docker<br>  script:<br>    - docker build --tag $DOCKER_IMAGE_NAME .<br>    - docker push $DOCKER_IMAGE_NAME</pre><p>As you can see in the former example, the npm command remains untouched but in fact, they execute the jf wrapper.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/302/0*TI06EwcUG6yVXDGE" /><figcaption>mission accomplished</figcaption></figure><p>We minimized the friction as much as possible and only add decorations. The core logic of the job remains untouched.</p><p>If we ever wish to revert or enhance it, we simply change the template.</p><p><em>I would like to thank </em><a href="https://www.linkedin.com/in/adam-richter-66b32a89/"><em>Adam Richter</em></a><em> and </em><a href="https://www.linkedin.com/in/assaf-mendelson-775b174/"><em>Assaf Mendelson</em></a><em> for their collaboration in implementing the above solution</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=52fd1d6e3119" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>