Semgrep SAST‑сканирование Rust, Go, Kotlin: Полное руководство по статическому анализу кода — пошаговая инструкция 2026

Исходный код (Rust/Go/Kotlin)

        ↓ Парсер (язык-специфичный)

  Абстрактное синтаксическое дерево (AST)

        ↓ Matcher

  Паттерн из правила (тоже парсится в AST)

        ↓ Tree-matching алгоритм

  Список совпадений → Findings

rules:

  - id: rule-unique-id           # Уникальный идентификатор

    patterns:                    # Условия срабатывания

      - pattern: |

          опасный_паттерн(...)

    message: >                   # Сообщение разработчику

      Описание уязвимости и рекомендация по исправлению.

      Подробнее: https://link-to-docs

    languages: [rust]            # Языки, для которых применяется правило

    severity: ERROR              # INFO / WARNING / ERROR

    metadata:

      category: security

      cwe: "CWE-119"

      confidence: HIGH

<h2 id="pattern-prostoe-sovpadenie">pattern — простое совпадение</h2>

<h2 id="pattern-not-isklyuchenie-patterna">pattern-not — исключение паттерна</h2>

<h2 id="pattern-either-logicheskoe-ili">pattern-either — логическое ИЛИ</h2>

<h2 id="pattern-inside-pattern-vnutri-konteksta">pattern-inside — паттерн внутри контекста</h2>

<h2 id="pattern-not-inside-pattern-vne-konteksta">pattern-not-inside — паттерн вне контекста</h2>

<h2 id="pattern-where-python-kastomnaya-python-logika-filtratsii">pattern-where-python — кастомная Python-логика фильтрации</h2>

<h2 id="focus-metavariable-fokus-na-konkretnoy-peremennoy">focus-metavariable — фокус на конкретной переменной</h2>

pip install semgrep

semgrep --version

<h2 id="semgrep-1-x-x">semgrep 1.x.x</h2>

brew install semgrep

docker pull semgrep/semgrep:latest

docker run --rm -v "${PWD}:/src" semgrep/semgrep \

  semgrep --config auto /src

<h2 id="skachat-aktualnyy-reliz-s-github-com-semgrep-semgrep-releases">Скачать актуальный релиз с github.com/semgrep/semgrep/releases</h2>

chmod +x semgrep-linux-x86_64

sudo mv semgrep-linux-x86_64 /usr/local/bin/semgrep

<h2 id="skanirovanie-tekuschego-kataloga">Сканирование текущего каталога</h2>

semgrep --config auto .



<h2 id="skanirovanie-s-podrobnym-vyvodom">Сканирование с подробным выводом</h2>

semgrep --config auto --verbose .



<h2 id="skanirovanie-tolko-security-pravil">Сканирование только security-правил</h2>

semgrep --config "p/security-audit" .



<h2 id="skanirovanie-konkretnogo-fayla">Сканирование конкретного файла</h2>

semgrep --config auto src/main.rs

<h2 id="pravila-bezopasnosti-dlya-rust">Правила безопасности для Rust</h2>

semgrep --config "p/rust" .



<h2 id="pravila-bezopasnosti-dlya-go">Правила безопасности для Go</h2>

semgrep --config "p/golang" .



<h2 id="pravila-dlya-kotlin-android">Правила для Kotlin / Android</h2>

semgrep --config "p/kotlin" .



<h2 id="owasp-top-10">OWASP Top 10</h2>

semgrep --config "p/owasp-top-ten" .



<h2 id="secrets-detection">Secrets detection</h2>

semgrep --config "p/secrets" .



<h2 id="cwe-top-25">CWE Top 25</h2>

semgrep --config "p/cwe-top-25" .

<h2 id="tekstovyy-vyvod-po-umolchaniyu">Текстовый вывод (по умолчанию)</h2>

semgrep --config auto .



<h2 id="json-dlya-dalneyshey-obrabotki">JSON для дальнейшей обработки</h2>

semgrep --config auto --json . > results.json



<h2 id="sarif-dlya-integratsii-s-github-code-scanning-vs-code">SARIF для интеграции с GitHub Code Scanning / VS Code</h2>

semgrep --config auto --sarif . > results.sarif



<h2 id="junit-xml-dlya-jenkins">JUnit XML для Jenkins</h2>

semgrep --config auto --junit-xml . > results.xml



<h2 id="vyvod-tolko-kriticheskih-oshibok">Вывод только критических ошибок</h2>

semgrep --config auto --severity ERROR .

{

  "results": [

    {

      "check_id": "rust.lang.security.unsafe-block-in-function",

      "path": "src/ffi.rs",

      "start": {"line": 42, "col": 5},

      "end":   {"line": 44, "col": 6},

      "extra": {

        "message": "Небезопасный блок без обоснования...",

        "severity": "WARNING",

        "metadata": {"cwe": "CWE-119", "confidence": "MEDIUM"}

      }

    }

  ],

  "stats": {

    "total_time": 2.34,

    "files_scanned": 87,

    "findings": 12

  }

}

rules:

  - id: rust-unsafe-block-no-comment

    pattern: |

      unsafe {

        $...BODY

      }

    pattern-not: |

      // SAFETY: $...

      unsafe {

        $...BODY

      }

    message: >

      Блок `unsafe` без комментария SAFETY:.

      По соглашению Rust каждый unsafe-блок должен содержать

      комментарий, обосновывающий его безопасность.

      Добавьте: // SAFETY: <обоснование>

    languages: [rust]

    severity: WARNING

    metadata:

      category: security

      cwe: "CWE-119"

rules:

  - id: rust-unwrap-in-non-test

    pattern: $EXPR.unwrap()

    pattern-not-inside: |

      #[test]

      fn $FUNC(...) {

        ...

      }

    pattern-not-inside: |

      #[cfg(test)]

      mod $MOD {

        ...

      }

    message: >

      Использование .unwrap() вне тестового кода приведёт к панике

      при ошибке. Используйте .expect("описание"), ?, или явную

      обработку через match/if let.

    languages: [rust]

    severity: WARNING

    metadata:

      category: reliability

      cwe: "CWE-248"

rules:

  - id: rust-mem-transmute

    patterns:

      - pattern: std::mem::transmute(...)

      - pattern: mem::transmute(...)

    message: >

      std::mem::transmute обходит систему типов Rust и является

      источником undefined behavior. Рассмотрите безопасные

      альтернативы: as-приведение, From/Into трейты, bytemuck::cast.

    languages: [rust]

    severity: ERROR

    metadata:

      category: security

      cwe: "CWE-704"

      confidence: HIGH

rules:

  - id: rust-weak-rng

    pattern-either:

      - pattern: rand::random::<$T>()

      - pattern: SmallRng::$METHOD(...)

      - pattern: StdRng::seed_from_u64(...)

    message: >

      Для криптографических задач (генерация токенов, ключей, паролей)

      используйте rand::rngs::OsRng или ring::rand::SystemRandom.

      Детерминированные и псевдослучайные генераторы предсказуемы.

    languages: [rust]

    severity: ERROR

    metadata:

      category: security

      cwe: "CWE-338"

rules:

  - id: rust-sql-injection-format

    patterns:

      - pattern: |

          let $QUERY = format!($TEMPLATE, ..., $USER_INPUT, ...);

      - pattern: |

          $DB.execute(&format!($TEMPLATE, ..., $USER_INPUT, ...), ...)

    message: >

      Конкатенация SQL-запроса с пользовательским вводом через format!

      создаёт уязвимость SQL-инъекции. Используйте параметризованные

      запросы: sqlx::query!(), diesel QueryDSL или rusqlite params![].

    languages: [rust]

    severity: ERROR

    metadata:

      cwe: "CWE-89"

<h2 id="vstroennye-pravila-reestra-dlya-rust">Встроенные правила реестра для Rust</h2>

semgrep --config "p/rust" --lang rust src/



<h2 id="kastomnye-pravila-iz-lokalnogo-kataloga">Кастомные правила из локального каталога</h2>

semgrep --config rules/rust/ --lang rust src/



<h2 id="tolko-error-uroven-sarif-vyvod-dlya-ide">Только ERROR-уровень, SARIF-вывод для IDE</h2>

semgrep --config "p/rust" --severity ERROR --sarif src/ > rust-findings.sarif



<h2 id="skanirovanie-s-metrikami-proizvoditelnosti">Сканирование с метриками производительности</h2>

semgrep --config "p/rust" --time --lang rust src/

rules:

  - id: go-tls-insecure-skip-verify

    patterns:

      - pattern: |

          tls.Config{..., InsecureSkipVerify: true, ...}

      - pattern: |

          &tls.Config{..., InsecureSkipVerify: true, ...}

    message: >

      InsecureSkipVerify: true отключает проверку TLS-сертификата сервера,

      что открывает соединение для MITM-атак. Никогда не используйте

      в продакшн-коде. Для тестирования используйте тестовые сертификаты.

    languages: [go]

    severity: ERROR

    metadata:

      cwe: "CWE-295"

      confidence: HIGH

      owasp: "A02:2021"

rules:

  - id: go-sql-injection-sprintf

    patterns:

      - pattern: |

          $DB.Query(fmt.Sprintf($QUERY, ..., $INPUT, ...), ...)

      - pattern: |

          $DB.Exec(fmt.Sprintf($QUERY, ..., $INPUT, ...), ...)

      - pattern: |

          $DB.QueryRow(fmt.Sprintf($QUERY, ..., $INPUT, ...), ...)

    message: >

      Конкатенация SQL через fmt.Sprintf создаёт уязвимость SQL-инъекции.

      Используйте параметризованные запросы:

      db.Query("SELECT * FROM users WHERE id = ?", userID)

      или ORM: GORM, sqlx с именованными параметрами.

    languages: [go]

    severity: ERROR

    metadata:

      cwe: "CWE-89"

      owasp: "A03:2021"

rules:

  - id: go-weak-random-math-rand

    patterns:

      - pattern: |

          import "math/rand"

      - pattern: rand.Intn(...)

      - pattern: rand.Int63(...)

      - pattern: rand.Float64(...)

    message: >

      math/rand генерирует предсказуемые числа. Для криптографических

      задач — генерации токенов, ключей, nonce — используйте crypto/rand:

        n, err := rand.Int(rand.Reader, max)

    languages: [go]

    severity: ERROR

    metadata:

      cwe: "CWE-338"

rules:

  - id: go-goroutine-leak-channel

    patterns:

      - pattern: |

          go func() {

            ...

            $CH <- $VAL

            ...

          }()

      - pattern-not-inside: |

          ctx, $CANCEL := context.WithCancel(...)

          ...

          defer $CANCEL()

          ...

    message: >

      Горутина пишет в канал без контекста отмены. Если получатель

      завершится раньше — горутина зависнет навсегда (goroutine leak).

      Используйте context.Context для управления временем жизни горутин:

        go func(ctx context.Context) { ... }(ctx)

    languages: [go]

    severity: WARNING

    metadata:

      cwe: "CWE-400"

rules:

  - id: go-path-traversal-http

    patterns:

      - pattern: |

          http.ServeFile($W, $R, $R.URL.Path)

      - pattern: |

          http.ServeFile($W, $R, filepath.Join($BASE, $R.URL.Path))

    message: >

      Использование r.URL.Path напрямую в http.ServeFile создаёт уязвимость

      Path Traversal (../../../etc/passwd). Используйте filepath.Clean()

      и проверяйте, что результирующий путь находится внутри разрешённой

      директории с помощью strings.HasPrefix().

    languages: [go]

    severity: ERROR

    metadata:

      cwe: "CWE-22"

      owasp: "A01:2021"

<h2 id="ofitsialnye-pravila-reestra-dlya-go">Официальные правила реестра для Go</h2>

semgrep --config "p/golang" .



<h2 id="pravila-owasp-dlya-go">Правила OWASP для Go</h2>

semgrep --config "p/owasp-top-ten" --lang go .



<h2 id="skanirovanie-s-isklyucheniem-vendor-i-testov">Сканирование с исключением vendor и тестов</h2>

semgrep --config "p/golang" \

  --exclude "vendor/" \

  --exclude "/*_test.go" \

  .



<h2 id="podschyot-nahodok-po-severity">Подсчёт находок по severity</h2>

semgrep --config "p/golang" --json . | \

  python3 -c "

import json, sys

from collections import Counter

d = json.load(sys.stdin)

c = Counter(r['extra']['severity'] for r in d['results'])

print(dict(c))

"

rules:

  - id: kotlin-password-in-shared-prefs

    patterns:

      - pattern: |

          $PREFS.edit().putString($KEY, $VALUE).apply()

      - pattern-either:

          - pattern: |

              $PREFS.edit().putString("password", ...)

          - pattern: |

              $PREFS.edit().putString("token", ...)

          - pattern: |

              $PREFS.edit().putString("secret", ...)

          - pattern: |

              $PREFS.edit().putString("api_key", ...)

    message: >

      SharedPreferences хранит данные в незашифрованном XML-файле.

      Для хранения секретов используйте Android Keystore System

      или EncryptedSharedPreferences из Jetpack Security:

        EncryptedSharedPreferences.create(context, fileName,

          masterKey, AES256_SIV, AES256_GCM)

    languages: [kotlin]

    severity: ERROR

    metadata:

      cwe: "CWE-312"

      owasp: "M9:2023"

rules:

  - id: kotlin-webview-javascript-enabled

    patterns:

      - pattern: |

          $WEBVIEW.settings.javaScriptEnabled = true

      - pattern-not-inside: |

          // SECURITY-REVIEW: $...

          $WEBVIEW.settings.javaScriptEnabled = true

    message: >

      Включение JavaScript в WebView без дополнительных ограничений

      создаёт поверхность для XSS и потенциального JavascriptInterface-

      злоупотребления. Если JavaScript необходим — добавьте:

        webView.settings.allowFileAccess = false

        webView.settings.allowContentAccess = false

      И используйте addJavascriptInterface только с @JavascriptInterface.

    languages: [kotlin]

    severity: ERROR

    metadata:

      cwe: "CWE-749"

      owasp: "M8:2023"

rules:

  - id: kotlin-sql-rawquery-injection

    patterns:

      - pattern: |

          $DB.rawQuery($QUERY + $INPUT, ...)

      - pattern: |

          $DB.rawQuery("$TEMPLATE${$INPUT}$REST", ...)

      - pattern: |

          $DB.execSQL($QUERY + $INPUT)

    message: >

      Конкатенация строк в rawQuery создаёт уязвимость SQL-инъекции.

      Используйте параметризованные запросы:

        db.rawQuery("SELECT * FROM users WHERE id = ?", arrayOf(userId))

      Или Room DAO с аннотациями @Query.

    languages: [kotlin]

    severity: ERROR

    metadata:

      cwe: "CWE-89"

rules:

  - id: kotlin-sensitive-data-logging

    patterns:

      - pattern-either:

          - pattern: Log.d($TAG, "...$PASSWORD...")

          - pattern: Log.i($TAG, "...$TOKEN...")

          - pattern: Log.v($TAG, $MSG)

          - pattern: println("password: $VALUE")

          - pattern: System.out.println("token: $VALUE")

    message: >

      Логирование потенциально чувствительных данных. Логи Android

      доступны другим приложениям с READ_LOGS-разрешением (до Android 4.1)

      и могут попасть в отчёты об ошибках. Не логируйте пароли, токены,

      PII. Для отладки используйте BuildConfig.DEBUG-условие.

    languages: [kotlin]

    severity: WARNING

    metadata:

      cwe: "CWE-532"

rules:

  - id: kotlin-implicit-intent-sensitive

    patterns:

      - pattern: |

          val $INTENT = Intent($ACTION)

          ...

          startActivity($INTENT)

      - pattern-not: |

          val $INTENT = Intent($ACTION)

          $INTENT.setPackage($PKG)

          ...

    message: >

      Неявный Intent без указания конкретного пакета может быть перехвачен

      вредоносным приложением (Intent Hijacking). Для передачи

      чувствительных данных используйте явные Intent с setPackage()

      или setComponent(). Используйте PendingIntent с FLAG_IMMUTABLE.

    languages: [kotlin]

    severity: WARNING

    metadata:

      cwe: "CWE-927"

      owasp: "M3:2023"

<h2 id="pravila-reestra-dlya-kotlin">Правила реестра для Kotlin</h2>

semgrep --config "p/kotlin" .



<h2 id="pravila-bezopasnosti-android">Правила безопасности Android</h2>

semgrep --config "p/android" .



<h2 id="isklyuchit-sgenerirovannyy-kod-i-testy">Исключить сгенерированный код и тесты</h2>

semgrep --config "p/kotlin" \

  --exclude "/build/" \

  --exclude "/*Test.kt" \

  --exclude "/*Spec.kt" \

  .



<h2 id="skanirovanie-s-vyvodom-v-sarif-dlya-android-studio">Сканирование с выводом в SARIF для Android Studio</h2>

semgrep --config "p/kotlin" --sarif . > kotlin-sast.sarif

<h2 id="x-lyuboe-odinochnoe-vyrazhenie-identifikator-ili-literal">$X — любое одиночное выражение, идентификатор или литерал</h2>

pattern: fmt.Sprintf($FORMAT, $X)



<h2 id="args-nol-ili-bolee-argumentov-variadic">$...ARGS — ноль или более аргументов (variadic)</h2>

pattern: fmt.Println($...ARGS)



<h2 id="type-var-peremennaya-s-lyubym-tipom">$TYPE $VAR — переменная с любым типом</h2>

pattern: var $TYPE $VAR = $VALUE



<h2 id="lyuboy-blok-koda-mnogostrochnyy-wildcard">&quot;...&quot; — любой блок кода (многострочный wildcard)</h2>

pattern: |

  func $FUNC(...) {

    ...

    dangerous_call(...)

    ...

  }

rules:

  - id: compound-example

    patterns:

      # Оба условия должны выполняться (AND)

      - pattern: $DB.Query($QUERY, ...)

      - pattern-not: $DB.Query("SELECT ...", ...)

    # pattern-either — хотя бы одно (OR)

    pattern-either:

      - pattern: db.Query(fmt.Sprintf(...))

      - pattern: db.Exec(fmt.Sprintf(...))

    # pattern-inside — паттерн внутри контекста

    pattern-inside: |

      func $HANDLER(w http.ResponseWriter, r *http.Request) {

        ...

      }

rules:

  - id: go-focus-user-input

    patterns:

      - pattern: $DB.Query($QUERY + $USER_INPUT, ...)

      - focus-metavariable: $USER_INPUT

    message: Пользовательский ввод $USER_INPUT попадает в SQL-запрос

    languages: [go]

    severity: ERROR

rules:

  - id: go-taint-http-to-sql

    mode: taint

    pattern-sources:

      - pattern: r.FormValue(...)

      - pattern: r.URL.Query().Get(...)

      - pattern: r.PostFormValue(...)

    pattern-sinks:

      - pattern: $DB.Query(...)

      - pattern: $DB.Exec(...)

      - pattern: $DB.QueryRow(...)

    pattern-sanitizers:

      - pattern: sqlEscape(...)

      - pattern: $DB.Prepare(...)

    message: >

      Данные из HTTP-запроса достигают SQL-запроса без санитизации.

      SQL-инъекция через пользовательский ввод.

    languages: [go]

    severity: ERROR

    metadata:

      cwe: "CWE-89"

      mode: taint

<h2 id="sozdat-testovyy-fayl-test-rule-go">Создать тестовый файл test_rule.go</h2>

<h2 id="zapustit-tolko-svoyo-pravilo-na-testovom-fayle">Запустить только своё правило на тестовом файле</h2>

semgrep --config rules/my_rule.yaml test_rule.go --verbose



<h2 id="zapustit-testy-pravil-po-soglasheniyu-ob-imenovanii">Запустить тесты правил по соглашению об именовании</h2>

<h2 id="fayly-test-lang-ryadom-s-pravilom">(файлы *_test.{lang} рядом с правилом)</h2>

semgrep --test rules/

rules:

  - id: rust-hardcoded-secret-entropy

    patterns:

      - pattern: |

          const $NAME: &str = "$VALUE";

      - metavariable-regex:

          metavariable: $NAME

          regex: '.*(KEY|SECRET|TOKEN|PASSWORD|PASS|PWD|API).*'

      - metavariable-regex:

          metavariable: $VALUE

          regex: '^[A-Za-z0-9+/]{20,}$'

    message: >

      Возможный хардкоженный секрет в константе $NAME.

      Используйте переменные окружения или системы управления секретами

      (HashiCorp Vault, AWS Secrets Manager).

    languages: [rust]

    severity: ERROR

    metadata:

      cwe: "CWE-798"

rules:

  - id: kotlin-cross-function-sql-injection

    mode: taint

    options:

      interfile: true          # Межфайловый анализ (Pro)

    pattern-sources:

      - pattern: |

          fun $HANDLER(request: HttpServletRequest): $RET {

            ...

            val $PARAM = request.getParameter(...)

            ...

          }

    pattern-sinks:

      - pattern: |

          $DB.execute($QUERY)

      - pattern: |

          $STMT.executeQuery($QUERY)

    message: Данные из HTTP-запроса достигают SQL-запроса (межфункционально)

    languages: [kotlin]

    severity: ERROR

<h2 id="skanirovanie-zavisimostey-rust-cargo-lock">Сканирование зависимостей Rust (Cargo.lock)</h2>

semgrep --config "p/r2c-security-audit" --supply-chain .



<h2 id="skanirovanie-go-modules-go-sum">Сканирование Go modules (go.sum)</h2>

semgrep --config "p/supply-chain" .



<h2 id="vyvod-naydennyh-cve-v-zavisimostyah">Вывод найденных CVE в зависимостях</h2>

semgrep --supply-chain --json . | \

  python3 -c "

import json, sys

d = json.load(sys.stdin)

for r in d.get('results', []):

    if 'sca_info' in r.get('extra', {}):

        print(r['extra']['sca_info'].get('cve', ''), r['path'])

"

<h2 id="zapusk-modulya-secrets-detection">Запуск модуля secrets detection</h2>

semgrep --config "p/secrets" .



<h2 id="poisk-tolko-vysokoentropiynyh-strok">Поиск только высокоэнтропийных строк</h2>

semgrep --config "p/gitleaks" .



<h2 id="primery-obnaruzhivaemyh-patternov">Примеры обнаруживаемых паттернов:</h2>

<h2 id="aws-access-key-akia-0-9a-z-16">AWS Access Key:  AKIA[0-9A-Z]{16}</h2>

<h2 id="github-token-ghp-a-za-z0-9-36">GitHub Token:    ghp_[A-Za-z0-9]{36}</h2>

<h2 id="private-key-begin-rsa-ec-openssh-private-key">Private Key:     -----BEGIN (RSA|EC|OPENSSH) PRIVATE KEY-----</h2>

<h2 id="jwt-eyj-a-za-z0-9-10-a-za-z0-9">JWT:             eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9._-]+</h2>

rules:

  - id: go-fix-insecure-tls

    pattern: |

      &tls.Config{..., InsecureSkipVerify: true, ...}

    fix: |

      &tls.Config{}

    message: Удалён InsecureSkipVerify: true

    languages: [go]

    severity: ERROR

<h2 id="primenit-avtoispravleniya">Применить автоисправления</h2>

semgrep --config rules/go-fixes.yaml --autofix .



<h2 id="posmotret-diff-bez-primeneniya">Посмотреть diff без применения</h2>

semgrep --config rules/go-fixes.yaml --autofix --dryrun .

<h2 id="nayti-vse-vyzovy-opasnyh-funktsiy-v-rust-faylah">Найти все вызовы опасных функций в Rust-файлах</h2>

semgrep -e 'std::mem::transmute(...)' --lang rust src/



<h2 id="nayti-vse-insert-zaprosy-s-formatirovaniem-v-go">Найти все INSERT-запросы с форматированием в Go</h2>

semgrep -e 'db.Exec(fmt.Sprintf($Q, ..., $X, ...))' --lang go .



<h2 id="nayti-vse-webview-loadurl-v-kotlin">Найти все WebView.loadUrl в Kotlin</h2>

semgrep -e '$WEBVIEW.loadUrl($URL)' --lang kotlin app/

<h2 id="github-workflows-semgrep-yml">.github/workflows/semgrep.yml</h2>

name: Semgrep SAST



on:

  push:

    branches: [main, develop]

  pull_request:

    branches: [main]

  schedule:

    # Полное сканирование каждую ночь

    - cron: '0 2 * * *'



jobs:

  semgrep:

    name: Semgrep Scan

    runs-on: ubuntu-latest

    container:

      image: semgrep/semgrep



    steps:

      - name: Checkout code

        uses: actions/checkout@v4



      - name: Run Semgrep (OSS)

        run: |

          semgrep \

            --config "p/rust" \

            --config "p/golang" \

            --config "p/kotlin" \

            --config "p/secrets" \

            --config "p/owasp-top-ten" \

            --sarif \

            --output semgrep-results.sarif \

            --error \

            .



      - name: Upload SARIF to GitHub Security

        uses: github/codeql-action/upload-sarif@v3

        if: always()

        with:

          sarif_file: semgrep-results.sarif



      - name: Upload results as artifact

        uses: actions/upload-artifact@v4

        if: always()

        with:

          name: semgrep-results

          path: semgrep-results.sarif

<h2 id="gitlab-ci-yml">.gitlab-ci.yml</h2>

semgrep-sast:

  image: semgrep/semgrep:latest

  stage: test

  script:

    - semgrep

        --config "p/rust"

        --config "p/golang"

        --config "p/kotlin"

        --config "p/secrets"

        --gitlab-sast

        --output gl-sast-report.json

        --error

        .

  artifacts:

    reports:

      sast: gl-sast-report.json

    paths:

      - gl-sast-report.json

    when: always

    expire_in: 1 week

  rules:

    - if: $CI_PIPELINE_SOURCE == "merge_request_event"

    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH

  allow_failure: false

// Jenkinsfile

pipeline {

    agent { docker { image 'semgrep/semgrep:latest' } }



    stages {

        stage('Semgrep SAST') {

            steps {

                script {

                    sh '''

                        semgrep \

                          --config "p/rust" \

                          --config "p/golang" \

                          --config "p/kotlin" \

                          --config "p/secrets" \

                          --json \

                          --output semgrep-results.json \

                          . || true

                    '''

                    // Подсчёт критических уязвимостей

                    def results = readJSON file: 'semgrep-results.json'

                    def errors = results.results.findAll {

                        it.extra.severity == 'ERROR'

                    }.size()



                    echo "Semgrep ERRORS: ${errors}"

                    if (errors > 0) {

                        error("Обнаружено ${errors} критических уязвимостей")

                    }

                }

            }

            post {

                always {

                    archiveArtifacts 'semgrep-results.json'

                    // Публикация в Jenkins Warnings NG Plugin

                    recordIssues(

                        tools: [sarif(pattern: 'semgrep-results.sarif')],

                        qualityGates: [[threshold: 1, type: 'TOTAL_ERROR', unstable: false]]

                    )

                }

            }

        }

    }

}

<h2 id="pre-commit-config-yaml">.pre-commit-config.yaml</h2>

repos:

  - repo: https://github.com/semgrep/semgrep

    rev: v1.x.x

    hooks:

      - id: semgrep

        args:

          - --config=p/secrets

          - --config=p/owasp-top-ten

          - --error

          - --quiet

        # Только изменённые файлы — быстро

        pass_filenames: true

<h2 id="ustanovka-i-aktivatsiya">Установка и активация</h2>

pip install pre-commit

pre-commit install

pre-commit run --all-files  # первый запуск по всем файлам

// Rust — подавление конкретного правила

let result = unsafe { // nosemgrep: rust-unsafe-block-no-comment

    dangerous_ffi_call()

};



// Подавление с обоснованием (рекомендуется)

// nosemgrep: rust-mem-transmute -- SAFETY: типы гарантированно совместимы по layout

let val: u64 = unsafe { std::mem::transmute(my_f64) };

// Go — подавление

config := &tls.Config{ // nosemgrep: go-tls-insecure-skip-verify

    InsecureSkipVerify: os.Getenv("ENV") == "test",

}

// Kotlin — подавление

webView.settings.javaScriptEnabled = true // nosemgrep: kotlin-webview-javascript-enabled

<h2 id="semgrepignore-sintaksis-kak-u-gitignore">.semgrepignore — синтаксис как у .gitignore</h2>

vendor/

node_modules/

/*_test.go

/*_generated.go

/mock_*.kt

target/

build/

dist/

*.pb.go          # Сгенерированный protobuf-код

/testdata/

<h2 id="shag-1-sozdat-baseline-iz-tekuschego-sostoyaniya-main-vetki">Шаг 1: Создать baseline из текущего состояния main-ветки</h2>

git checkout main

semgrep --config "p/golang" --json . > baseline.json



<h2 id="shag-2-v-ci-sravnivat-tolko-s-novymi-nahodkami">Шаг 2: В CI сравнивать только с новыми находками</h2>

semgrep --config "p/golang" --json . > current.json



<h2 id="shag-3-nayti-tolko-novye-python-skript">Шаг 3: Найти только новые (python-скрипт)</h2>

python3 - <<'EOF'

import json



with open('baseline.json') as f:

    baseline = {(r['check_id'], r['path'], r['start']['line'])

                for r in json.load(f)['results']}



with open('current.json') as f:

    current = json.load(f)['results']



new_findings = [r for r in current

                if (r['check_id'], r['path'], r['start']['line'])

                not in baseline]



print(f"Новые уязвимости: {len(new_findings)}")

for f in new_findings:

    print(f"  {f['check_id']} — {f['path']}:{f['start']['line']}")

EOF

<h2 id="tolko-vysokaya-uverennost-error">Только высокая уверенность + ERROR</h2>

semgrep --config "p/golang" \

  --severity ERROR \

  --json . | \

  python3 -c "

import json, sys

d = json.load(sys.stdin)

high = [r for r in d['results']

        if r.get('extra', {}).get('metadata', {}).get('confidence') == 'HIGH']

print(json.dumps({'results': high}, indent=2))

"

(быстро, каждый PR):

  → Очевидные уязвимости, типичные паттерны, secrets

  → Кастомные правила под фреймворк проекта

  → Блокировка PR при нахождении ERROR



CodeQL (медленно, ночной скан):

  → Глубокий межпроцедурный taint-анализ

  → Сложные цепочки уязвимостей

  → Не блокирует PR, создаёт issues для team lead

.semgrep/

├── rules/

│   ├── rust/

│   │   ├── memory-safety.yaml

│   │   ├── crypto.yaml

│   │   └── ffi.yaml

│   ├── go/

│   │   ├── http-security.yaml

│   │   ├── sql-injection.yaml

│   │   └── goroutine-safety.yaml

│   ├── kotlin/

│   │   ├── android-security.yaml

│   │   └── serialization.yaml

│   └── common/

│       ├── secrets.yaml

│       └── hardcoded-values.yaml

├── .semgrepignore

└── semgrep.yml          # Основной конфиг с наборами правил

<h2 id="semgrep-semgrep-yml">.semgrep/semgrep.yml</h2>

rules_dirs:

  - .semgrep/rules/

configs:

  - "p/secrets"

  - "p/owasp-top-ten"

<h2 id="semgrep-policy-yaml-politika-dlya-komandy">semgrep-policy.yaml — политика для команды</h2>

policies:

  block_on_error: true           # Блокировать PR при ERROR

  block_on_warning: false        # Не блокировать при WARNING

  notify_on: [ERROR, WARNING]

  exceptions:

    - rule_id: "rust-unsafe-block-no-comment"

      repos: ["kernel-module"]   # Исключение для конкретного репо

      reason: "Reviewed by security team"

<h2 id="svodnyy-otchyot-po-vsem-repozitoriyam-organizatsii">Сводный отчёт по всем репозиториям организации</h2>

semgrep --config "p/security-audit" \

  --json \

  --metrics=off \

  . | python3 - <<'EOF'

import json, sys

from collections import Counter, defaultdict



data = json.load(sys.stdin)

by_rule = Counter(r['check_id'] for r in data['results'])

by_severity = Counter(

    r['extra']['severity'] for r in data['results']

)

by_file = defaultdict(int)

for r in data['results']:

    by_file[r['path']] += 1



print(f"\n=== SAST ОТЧЁТ ===")

print(f"Всего уязвимостей: {len(data['results'])}")

print(f"По severity: {dict(by_severity)}")

print(f"\nТоп-5 правил:")

for rule, count in by_rule.most_common(5):

    print(f"  {rule}: {count}")

print(f"\nТоп-5 файлов:")

for path, count in sorted(by_file.items(), key=lambda x: -x[1])[:5]:

    print(f"  {path}: {count}")

EOF

// Обнаружено Semgrep: src/ffi/payment.rs:142

pub fn process_raw_buffer(ptr: *mut u8, len: usize) -> ProcessResult {

    unsafe {

        // Нет комментария SAFETY:

        let slice = std::slice::from_raw_parts_mut(ptr, len);

        // ...

    }

}

pub fn process_raw_buffer(ptr: *mut u8, len: usize) -> ProcessResult {

    assert!(!ptr.is_null(), "ptr must not be null");

    assert!(len <= MAX_BUFFER_SIZE, "len exceeds maximum");

    // SAFETY: ptr ненулевой и len проверен выше. Вызывающая сторона

    // гарантирует валидность памяти через контракт FFI.

    unsafe {

        let slice = std::slice::from_raw_parts_mut(ptr, len);

        // ...

    }

}

// Обнаружено правилом go-taint-http-to-sql: api/handlers/search.go:67

func SearchHandler(w http.ResponseWriter, r *http.Request) {

    category := r.FormValue("category")  // SOURCE

    query := fmt.Sprintf(

        "SELECT * FROM products WHERE category = '%s'", category)

    rows, err := db.Query(query)  // SINK

    // ...

}

func SearchHandler(w http.ResponseWriter, r *http.Request) {

    category := r.FormValue("category")

    rows, err := db.Query(

        "SELECT * FROM products WHERE category = ?", category)

    // ...

}

// Обнаружено: app/src/main/java/com/example/ApiClient.kt:12

companion object {

    const val API_KEY = "sk-prod-a8f2e1b9c3d7e4f6a2b8c1d5e3f7a9b2c4d6e8f0"  // ERROR

    const val BASE_URL = "https://api.example.com"

}

// build.gradle.kts

android {

    buildFeatures { buildConfig = true }

    buildTypes.configureEach {

        buildConfigField("String", "API_KEY",

            "\"${properties["API_KEY"]}\"")

    }

}

// Использование:

val apiKey = BuildConfig.API_KEY

// Обнаружено: worker/processor.go:89

func processItems(items []Item) {

    results := make(chan Result)

    for _, item := range items {

        go func(i Item) {           // Горутина без ctx

            results <- process(i)  // Если получатель закрыт — зависнет

        }(item)

    }

    // ...

}

func processItems(ctx context.Context, items []Item) {

    results := make(chan Result, len(items))

    for _, item := range items {

        go func(ctx context.Context, i Item) {

            select {

            case results <- process(i):

            case <-ctx.Done():

                return

            }

        }(ctx, item)

    }

}