### Pacchetti di terze parti

Ci sono diversi pacchetti **di terze parti** per `pip-audit`. Le matrici e i badge sottostanti elencano alcuni di essi:

[![Packaging status](https://repology.org/badge/vertical-allrepos/python:pip-audit.svg)](https://repology.org/project/python:pip-audit/versions)
[![Packaging status](https://repology.org/badge/vertical-allrepos/pip-audit.svg)](https://repology.org/project/pip-audit/versions)
[![Conda - Platform](https://img.shields.io/conda/pn/conda-forge/pip-audit?logo=anaconda&style=flat)][#conda-forge-package]
[![Conda (channel only)](https://img.shields.io/conda/vn/conda-forge/pip-audit?logo=anaconda&style=flat&color=orange)][#conda-forge-package]

[#conda-forge-package]: https://anaconda.org/conda-forge/pip-audit

In particolare, `pip-audit` può essere installato tramite `conda`:```bash
conda install -c conda-forge pip-audit

Vedi la
[documentazione dell'azione](https://github.com/pypa/gh-action-pip-audit/blob/main/README.md)
per maggiori dettagli ed esempi di utilizzo.

### Supporto di `pre-commit`

`pip-audit` supporta [`pre-commit`](https://pre-commit.com/).

Ad esempio, utilizzando `pip-audit` tramite `pre-commit` per verificare un file dei requisiti:```yaml
  - repo: https://github.com/pypa/pip-audit
    rev: v2.10.1
    hooks:
      -   id: pip-audit
          args: ["-r", "requirements.txt"]

ci:
  # Leave pip-audit to only run locally and not in CI
  # pre-commit.ci does not allow network calls
  skip: [pip-audit]

<!-- @begin-pip-audit-help@ -->```
usage: pip-audit [-h] [-V] [-l] [-r REQUIREMENT] [--locked] [-f FORMAT]
                 [-s SERVICE] [--osv-url OSV_URL] [-d] [-S]
                 [--desc [{on,off,auto}]] [--aliases [{on,off,auto}]]
                 [--cache-dir CACHE_DIR] [--progress-spinner {on,off}]
                 [--timeout TIMEOUT] [--path PATH] [-v] [--fix]
                 [--require-hashes] [--index-url INDEX_URL]
                 [--extra-index-url URL] [--skip-editable] [--no-deps]
                 [-o FILE] [--ignore-vuln ID] [--disable-pip]
                 [project_path]

audit the Python environment for dependencies with known vulnerabilities

positional arguments:
  project_path          audit a local Python project at the given path
                        (default: None)

options:
  -h, --help            show this help message and exit
  -V, --version         show program's version number and exit
  -l, --local           show only results for dependencies in the local
                        environment (default: False)
  -r REQUIREMENT, --requirement REQUIREMENT
                        audit the given requirements file; this option can be
                        used multiple times (default: None)
  --locked              audit lock files from the local Python project. This
                        flag only applies to auditing from project paths
                        (default: False)
  -f FORMAT, --format FORMAT
                        the format to emit audit results in (choices: columns,
                        json, cyclonedx-json, cyclonedx-xml, markdown)
                        (default: columns)
  -s SERVICE, --vulnerability-service SERVICE
                        the vulnerability service to audit dependencies
                        against (choices: osv, pypi, esms) (default: pypi)
  --osv-url OSV_URL     URL to use for the OSV API instead of the default
                        (default: https://api.osv.dev/v1/query)
  -d, --dry-run         without `--fix`: collect all dependencies but do not
                        perform the auditing step; with `--fix`: perform the
                        auditing step but do not perform any fixes (default:
                        False)
  -S, --strict          fail the entire audit if dependency collection fails
                        on any dependency (default: False)
  --desc [{on,off,auto}]
                        include a description for each vulnerability; `auto`
                        defaults to `on` for the `json` format. This flag has
                        no effect on the `cyclonedx-json` or `cyclonedx-xml`
                        formats. (default: auto)
  --aliases [{on,off,auto}]
                        includes alias IDs for each vulnerability; `auto`
                        defaults to `on` for the `json` format. This flag has
                        no effect on the `cyclonedx-json` or `cyclonedx-xml`
                        formats. (default: auto)
  --cache-dir CACHE_DIR
                        the directory to use as an HTTP cache for PyPI; uses
                        the `pip` HTTP cache by default (default: None)
  --progress-spinner {on,off}
                        display a progress spinner (default: on)
  --timeout TIMEOUT     set the socket timeout (default: 15)
  --path PATH           restrict to the specified installation path for
                        auditing packages; this option can be used multiple
                        times (default: [])
  -v, --verbose         run with additional debug logging; supply multiple
                        times to increase verbosity (default: 0)
  --fix                 automatically upgrade dependencies with known
                        vulnerabilities (default: False)
  --require-hashes      require a hash to check each requirement against, for
                        repeatable audits; this option is implied when any
                        package in a requirements file has a `--hash` option.
                        (default: False)
  --index-url INDEX_URL
                        base URL of the Python Package Index; this should
                        point to a repository compliant with PEP 503 (the
                        simple repository API); this will be resolved by pip
                        if not specified (default: None)
  --extra-index-url URL
                        extra URLs of package indexes to use in addition to
                        `--index-url`; should follow the same rules as
                        `--index-url` (default: [])
  --skip-editable       don't audit packages that are marked as editable
                        (default: False)
  --no-deps             don't perform any dependency resolution; requires all
                        requirements are pinned to an exact version (default:
                        False)
  -o FILE, --output FILE
                        output results to the given file (default: stdout)
  --ignore-vuln ID      ignore a specific vulnerability by its vulnerability
                        ID; this option can be used multiple times (default:
                        [])
  --disable-pip         don't use `pip` for dependency resolution; this can
                        only be used with hashed requirements files or if the
                        `--no-deps` flag has been provided (default: False)

Controlla le dipendenze per un dato file di requisiti:```console
$ pip-audit -r ./requirements.txt
No known vulnerabilities found

Verifica delle dipendenze per un progetto Python locale:```console
$ pip-audit .
No known vulnerabilities found

`pip-audit` cerca nel percorso fornito vari file "progetto" Python.
Al momento, sono supportati solo `pyproject.toml` e `pylock.*.toml`.

Controlla le dipendenze quando sono presenti vulnerabilità:```console
$ pip-audit
Found 2 known vulnerabilities in 1 package
Name  Version ID             Fix Versions
----  ------- -------------- ------------
Flask 0.5     PYSEC-2019-179 1.0
Flask 0.5     PYSEC-2018-66  0.12.3

Controlla le dipendenze incluse le descrizioni:```console
$ pip-audit --desc
Found 2 known vulnerabilities in 1 package
Name  Version ID             Fix Versions Description
----  ------- -------------- ------------ --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Flask 0.5     PYSEC-2019-179 1.0          The Pallets Project Flask before 1.0 is affected by: unexpected memory usage. The impact is: denial of service. The attack vector is: crafted encoded JSON data. The fixed version is: 1. NOTE: this may overlap CVE-2018-1000656.
Flask 0.5     PYSEC-2018-66  0.12.3       The Pallets Project flask version Before 0.12.3 contains a CWE-20: Improper Input Validation vulnerability in flask that can result in Large amount of memory usage possibly leading to denial of service. This attack appear to be exploitable via Attacker provides JSON data in incorrect encoding. This vulnerability appears to have been fixed in 0.12.3. NOTE: this may overlap CVE-2019-1010083.

Verifica e tenta di aggiornare automaticamente le dipendenze vulnerabili:```console
$ pip-audit --fix
Found 2 known vulnerabilities in 1 package and fixed 2 vulnerabilities in 1 package
Name  Version ID             Fix Versions Applied Fix
----- ------- -------------- ------------ ----------------------------------------
flask 0.5     PYSEC-2019-179 1.0          Successfully upgraded flask (0.5 => 1.0)
flask 0.5     PYSEC-2018-66  0.12.3       Successfully upgraded flask (0.5 => 1.0)

L'opzione `--ignore-vuln ID` funziona con tutte le altre opzioni di risoluzione delle dipendenze e di auditing, il che significa che dovrebbe funzionare correttamente con input in formato requirements, feed di vulnerabilità alternativi e così via.

Può anche essere passata più volte, per ignorare più report:```console
# Run the audit as normal, but exclude any reports that match these IDs
$ pip-audit --ignore-vuln CVE-XXX-YYYY --ignore-vuln CVE-ZZZ-AAAA

In alternativa, se il tuo input è completamente bloccato (e opzionalmente hashato),
puoi dire a `pip-audit` di saltare la risoluzione delle dipendenze con `--no-deps`
(bloccato senza hash) o `--require-hashes` (bloccato con hash inclusi).

La seconda è equivalente a `pip`'s
[modalità di controllo hash](https://pip.pypa.io/en/stable/cli/pip_install/#hash-checking-mode)
ed è preferibile, poiché offre una maggiore integrità.```console
# fails if any dependency is not fully pinned
$ pip-audit --no-deps -r requirements.txt

# fails if any dependency is not fully pinned *or* is missing hashes
$ pip-audit --require-hashes -r requirements.txt

### Soppressione dei codici di uscita da `pip-audit`

`pip-audit` non supporta intenzionalmente la soppressione interna dei propri codici di uscita.

Gli utenti che devono sopprimere una chiamata fallita di `pip-audit` possono utilizzare uno dei modi standard della shell per farlo:

pip-audit || true
```
oppure, per uscire completamente:```bash
pip-audit || exit 0
```
Il codice di uscita può anche essere catturato e gestito esplicitamente:```bash
pip-audit
exitcode="${?}"
# do something with ${exitcode}
```
Vedi [Codici di uscita](#exit-codes) per un elenco dei codici potenziali che necessitano di gestione.

### Segnalazione solo delle vulnerabilità risolvibili

Nei flussi di lavoro di sviluppo, potresti voler ignorare le vulnerabilità che non sono state ancora risolte e investigarle solo nel processo di rilascio. `pip-audit` non supporta l'ignorare le vulnerabilità non risolte. Tuttavia, puoi esportare il suo output in formato JSON ed elaborarlo esternamente. Ad esempio, se vuoi uscire con un codice non zero solo quando le vulnerabilità rilevate hanno versioni di fix conosciute, puoi elaborare l'output usando [jq](https://github.com/jqlang/jq) come:```shell
test -z "$(pip-audit -r requirements.txt --format=json 2>/dev/null | jq '.dependencies[].vulns[].fix_versions[]')"
```
Un esempio semplice (e inefficiente) dell'utilizzo di questo metodo potrebbe essere:```shell
test -z "$(pip-audit -r requirements.txt --format=json 2>/dev/null | jq '.dependencies[].vulns[].fix_versions[]')" || pip-audit -r requirements.txt
```
che esegue `pip-audit` come al solito e termina con un codice diverso da zero solo se esistono versioni corrette per le vulnerabilità note.

## Modello di Sicurezza

Questa sezione esiste per descrivere le ipotesi di sicurezza che **puoi** e **non devi** fare quando usi `pip-audit`.

TL;DR: **Se non lo `pip install`eresti, non dovresti `pip audit`arlo.**

`pip-audit` è uno strumento per controllare gli ambienti Python alla ricerca di pacchetti con *vulnerabilità note*. Una "vulnerabilità nota" è un difetto segnalato pubblicamente in un pacchetto che, se non corretto, *potrebbe* permettere a un attore malevolo di compiere azioni non desiderate.

`pip-audit` **può** proteggerti dalle vulnerabilità note dicendoti quando le hai e come dovresti aggiornarle. Ad esempio, se hai `somepackage==1.2.3` nel tuo ambiente, `pip-audit` **può** dirti che deve essere aggiornato a `1.2.4`.

Puoi **assumere** che `pip-audit` farà del suo meglio per *risolvere completamente* tutte le tue dipendenze Python e *o* controllarle completamente *oppure* dichiarare esplicitamente quali ha saltato e perché.

`pip-audit` **non** è un analizzatore statico di codice. Analizza alberi delle dipendenze, non codice, e **non può** garantire che risoluzioni arbitrarie delle dipendenze avvengano staticamente. Per capire perché, fai riferimento all'[eccellente articolo di Dustin Ingram sulla risoluzione delle dipendenze in Python](https://dustingram.com/articles/2018/03/05/why-pypi-doesnt-know-dependencies/).

Pertanto: **non devi** dare per scontato che `pip-audit` ti **difenda** da pacchetti malevoli. In particolare, è **sbagliato** considerare `pip-audit -r INPUT` come una variante "più sicura" di `pip-audit`. A tutti gli effetti, `pip-audit -r INPUT` è funzionalmente equivalente a `pip install -r INPUT`, con una piccola dose di **isolamento non di sicurezza** per evitare conflitti con i tuoi ambienti locali.

`pip-audit` è prima di tutto uno strumento di controllo per pacchetti *Python*. **Non devi** presumere che `pip-audit` rilevi o segnali vulnerabilità "transitive" che potrebbero essere esposte attraverso pacchetti Python, ma non fanno effettivamente parte del pacchetto stesso. Ad esempio, è improbabile che le fonti di informazioni sulle vulnerabilità di `pip-audit` includano un avviso per una libreria condivisa vulnerabile che un popolare pacchetto Python *potrebbe* utilizzare, poiché la versione del pacchetto Python non è fortemente collegata alla versione della libreria condivisa.

## Licenza

`pip-audit` è concesso in licenza secondo la licenza Apache 2.0.

`pip-audit` riutilizza e modifica esempi da [`resolvelib`](https://github.com/sarugaku/resolvelib), che è concesso in licenza secondo la licenza ISC.

## Contributi

Vedi [la documentazione per contribuire](https://github.com/pypa/pip-audit/blob/main/CONTRIBUTING.md) per i dettagli.

## Codice di Condotta

Chiunque interagisca con questo progetto è tenuto a seguire il [Codice di Condotta della PSF](https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md).