### तृतीय-पक्ष पैकेज

`pip-audit` के लिए कई **तृतीय-पक्ष** पैकेज हैं। नीचे दिए गए मैट्रिक्स और बैज उनमें से कुछ को सूचीबद्ध करते हैं:

[![पैकेजिंग स्थिति](https://repology.org/badge/vertical-allrepos/python:pip-audit.svg)](https://repology.org/project/python:pip-audit/versions)
[![पैकेजिंग स्थिति](https://repology.org/badge/vertical-allrepos/pip-audit.svg)](https://repology.org/project/pip-audit/versions)
[![कोंडा - प्लेटफ़ॉर्म](https://img.shields.io/conda/pn/conda-forge/pip-audit?logo=anaconda&style=flat)][#conda-forge-package]
[![कोंडा (केवल चैनल)](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

विशेष रूप से, `pip-audit` को `conda` के माध्यम से स्थापित किया जा सकता है:```bash
conda install -c conda-forge pip-audit

See the
[एक्शन दस्तावेज़ीकरण](https://github.com/pypa/gh-action-pip-audit/blob/main/README.md)
अधिक विवरण और उपयोग उदाहरणों के लिए।

### `pre-commit` समर्थन

`pip-audit` में [`pre-commit`](https://pre-commit.com/) का समर्थन है।

उदाहरण के लिए, `pip-audit` का उपयोग करके `pre-commit` के माध्यम से एक आवश्यकताएँ फ़ाइल का ऑडिट करना:```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)

किसी दिए गए आवश्यकता फ़ाइल के लिए निर्भरताओं का ऑडिट करें:```console
$ pip-audit -r ./requirements.txt
No known vulnerabilities found

स्थानीय Python प्रोजेक्ट के लिए निर्भरताओं का ऑडिट करें:```console
$ pip-audit .
No known vulnerabilities found

`pip-audit` दिए गए पथ में विभिन्न Python "प्रोजेक्ट" फ़ाइलों की खोज करता है।
फिलहाल, केवल `pyproject.toml` और `pylock.*.toml` समर्थित हैं।

जब कमजोरियाँ मौजूद हों तब निर्भरताओं का ऑडिट करें:```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

विवरण सहित निर्भरताओं का ऑडिट करें:```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.

कमजोर निर्भरताओं की ऑडिट करें और स्वचालित रूप से अपग्रेड करने का प्रयास करें:```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)

`--ignore-vuln ID` विकल्प सभी अन्य निर्भरता समाधान
और ऑडिटिंग विकल्पों के साथ काम करता है, जिसका अर्थ है कि यह आवश्यकता-शैली इनपुट,
वैकल्पिक भेद्यता फ़ीड, और इसी तरह के साथ सही ढंग से कार्य करना चाहिए।

इसे कई बार पास किया जा सकता है, कई रिपोर्टों को अनदेखा करने के लिए:```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

वैकल्पिक रूप से, यदि आपका इनपुट पूरी तरह से पिन किया गया है (और वैकल्पिक रूप से हैश किया गया है), आप
`pip-audit` को या तो `--no-deps` (बिना हैश के पिन किया गया) या `--require-hashes` (हैश सहित पिन किया गया) के साथ निर्भरता समाधान छोड़ने के लिए कह सकते हैं।

बाद वाला `pip` के [हैश-जांच मोड](https://pip.pypa.io/en/stable/cli/pip_install/#hash-checking-mode) के समतुल्य है और इसे प्राथमिकता दी जाती है, क्योंकि यह अतिरिक्त अखंडता प्रदान करता है।```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

### `pip-audit` से निकास कोड को दबाना

`pip-audit` जानबूझकर अपने स्वयं के निकास कोड को आंतरिक रूप से दबाने का समर्थन नहीं करता है।

जिन उपयोगकर्ताओं को एक असफल `pip-audit` आह्वान के निकास कोड को दबाने की आवश्यकता है, वे ऐसा करने के लिए मानक शेल मुहावरों में से एक का उपयोग कर सकते हैं:

pip-audit || true
```
या, पूरी तरह से बाहर निकलने के लिए:```bash
pip-audit || exit 0
```
exit code को स्पष्ट रूप से कैप्चर और हैंडल भी किया जा सकता है:```bash
pip-audit
exitcode="${?}"
# do something with ${exitcode}
```
संभावित कोड की सूची के लिए [निकास कोड](#exit-codes) देखें जिन्हें संभालने की आवश्यकता है।

### केवल सुधार योग्य कमजोरियों की रिपोर्ट करना

विकास कार्यप्रवाहों में, आप उन कमजोरियों को अनदेखा करना चाह सकते हैं जिनका अभी तक समाधान नहीं किया गया है और केवल अपनी रिलीज़ प्रक्रिया में उनकी जांच करना चाह सकते हैं। `pip-audit` अनसुलझी कमजोरियों को अनदेखा करने का समर्थन नहीं करता है। हालांकि, आप इसके आउटपुट को JSON प्रारूप में निर्यात कर सकते हैं और बाहरी रूप से प्रोसेस कर सकते हैं। उदाहरण के लिए, यदि आप केवल तब गैर-शून्य कोड के साथ बाहर निकलना चाहते हैं जब पाई गई कमजोरियों के ज्ञात सुधार संस्करण हों, तो आप [jq](https://github.com/jqlang/jq) का उपयोग करके आउटपुट को प्रोसेस कर सकते हैं:```shell
test -z "$(pip-audit -r requirements.txt --format=json 2>/dev/null | jq '.dependencies[].vulns[].fix_versions[]')"
```
इस विधि का उपयोग करने का एक सरल (और अकुशल) उदाहरण होगा:```shell
test -z "$(pip-audit -r requirements.txt --format=json 2>/dev/null | jq '.dependencies[].vulns[].fix_versions[]')" || pip-audit -r requirements.txt
```
which runs `pip-audit` as usual and exits with a non-zero code only if there are fixed versions for the known vulnerabilities.

## Security Model

This section exists to describe the security assumptions you **can** and **must not**
make when using `pip-audit`.

TL;DR: **If you wouldn't `pip install` it, you should not `pip audit` it.**

`pip-audit` is a tool for auditing Python environments for packages with
*known vulnerabilities*. A "known vulnerability" is a publicly reported flaw in
a package that, if uncorrected, *might* allow a malicious actor to perform
unintended actions.

`pip-audit` **can** protect you against known vulnerabilities by telling
you when you have them, and how you should upgrade them. For example,
if you have `somepackage==1.2.3` in your environment, `pip-audit` **can** tell
you that it needs to be upgraded to `1.2.4`.

You **can** assume that `pip-audit` will make a best effort to *fully resolve*
all of your Python dependencies and *either* fully audit each *or* explicitly
state which ones it has skipped, as well as why it has skipped them.

`pip-audit` is **not** a static code analyzer. It analyzes dependency trees,
not code, and it **cannot** guarantee that arbitrary dependency resolutions
occur statically. To understand why this is, refer to Dustin Ingram's
[excellent post on dependency resolution in Python](https://dustingram.com/articles/2018/03/05/why-pypi-doesnt-know-dependencies/).

As such: you **must not** assume that `pip-audit` will **defend** you against
malicious packages. In particular, it is **incorrect** to treat
`pip-audit -r INPUT` as a "more secure" variant of `pip-audit`. For all intents
and purposes, `pip-audit -r INPUT` is functionally equivalent to
`pip install -r INPUT`, with a small amount of **non-security isolation** to
avoid conflicts with any of your local environments.

`pip-audit` is first and foremost an auditing tool for *Python* packages.
You **must not** assume that `pip-audit` will detect or flag "transitive"
vulnerabilities that might be exposed through Python packages, but are not
actually part of the package itself. For example, `pip-audit`'s vulnerability
information sources are unlikely to include an advisory for a vulnerable shared
library that a popular Python package *might* use, since the Python package's
version is not strongly connected to the shared library's version.

## Licensing

`pip-audit` is licensed under the Apache 2.0 License.

`pip-audit` reuses and modifies examples from
[`resolvelib`](https://github.com/sarugaku/resolvelib), which is licensed under
the ISC license.

## Contributing

See [the contributing docs](https://github.com/pypa/pip-audit/blob/main/CONTRIBUTING.md) for details.

## Code of Conduct

Everyone interacting with this project is expected to follow the
[PSF Code of Conduct](https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md).