Artifactspublic-v0

curl

master
ply4 git calls40 ms290 KiB3 cachedprotocol v2
168 lines6.8 KiBRaw

Verify

Do not trust, verify!

Signed releases

Every curl release is shipped as a set of tarballs. They all have the exact same content but use different archivers, visible by the different file extensions used.

Each tarball is signed by the curl release manager Daniel. The digital signatures for each tarball are always provided. The digital signatures can be used to verify that the tarballs were produced by Daniel.

If the curl website were breached and fake curl releases were provided, they could be detected using these signatures.

Daniel's public GPG key: 27ED EAF2 2F3A BCEB 50DB 9A12 5CC9 08FD B71E 12C2

Reproducible releases

The curl project ships reproducible releases. This means that everyone is able - and encouraged - to independently verify the contents of every curl release. Verify that it contains exactly the bits that are supposed to be in the release and nothing extra.

The curl releases are generated using a Docker image to make it easy to get an identical setup. To verify an existing curl release, we provide a convenient script that generates a new curl release from source code and then compares this newly generated release tarball with the tarball file you downloaded from curl.se.

For full verification, invoke the script inside an up-to-date curl source code git repository. Without a git repository present, it does a lighter check by rebuilding the release using the files in the tarball.

Note: full verification mode checks out the release tag in your repository. Run it in a clean working tree (no local changes) or a dedicated clone.

Invoke it like this:

git clone https://github.com/curl/curl
cd curl
mv [download-dir]/curl-8.19.0.tar.xz .
./scripts/verify-release curl-8.19.0.tar.xz

A successful check ends up with a final output similar to:

curl-8.19.0.tar.xz: OK

By verifying the release tarballs, you verify that Daniel does not infect the release on purpose or involuntarily because of anything malicious running in his setup.

Verify the verify

Of course you should not blindly trust the verification script. It is short and simple and should be quick to verify. Or you write your own script that you trust, to do the same job.

Source code

How do you then verify that what is in git is fine to build a product from?

In the curl project we verify the source code in multiple ways, and one way to gain trust is to verify and review our testing procedures.

  • we have a consistent code style (invalid style causes errors)

  • we ban and avoid a number of "sensitive" and "hard-to-use" C functions (use of such functions causes errors)

  • we have a ceiling for complexity in functions to keep them easy to follow, read and understand (failing to do so causes errors)

  • we review all pull requests before merging, both with humans and with bots. We link back commits to their origin pull requests in commit messages.

  • we ban use of "binary blobs" in git to not provide means for malicious actors to bundle encrypted payloads (trying to include a blob causes errors)

  • every single file in the git repository has a clear copyright and license statement. Complete knowledge and tracking of provenience.

  • we actively avoid base64 encoded chunks as they too could function as ways to obfuscate malicious contents

  • we forbid and prevent git force push on the master branch. History cannot be rewritten.

  • we ban most uses of UTF-8 in code and documentation to avoid easily mixed up Unicode characters that look like other characters. (adding Unicode characters causes errors)

  • we document everything to make it clear how things are supposed to work. No surprises. Lots of documentation is tested and verified in addition to spellchecks and consistent wording.

  • we have thousands of tests and we add test cases for (ideally) every functionality. Finding "white spots" and adding coverage is a top priority. curl runs on countless operating systems, CPU architectures and you can build curl in billions of different configuration setups: not every combination is practically possible to test

  • we build curl and run tests in over two hundred CI jobs that are run for every commit and every PR. We do not merge commits that have unexplained test failures.

  • we run all tests as "torture tests", where each test case is rerun to have every invoked fallible function call fail once each, to make sure curl never leaks memory or crashes due to this.

  • we build curl in CI with the most picky compiler options enabled and we never allow compiler warnings to linger. We always use -Werror that converts warnings to errors and fail the builds.

  • we run all tests using valgrind and several combinations of sanitizers to find and reduce the risk for memory problems, undefined behavior and similar

  • we keep running static code analyzers on the code, both traditional ones (clang-tidy, CodeSonar, Coverity) but also new generation AI powered ones like Zeropath and Codex Security.

  • we run fuzzing on curl: non-stop as part of Google's OSS-Fuzz project, but also briefly as part of the CI setup for every commit and PR

  • we make sure that the CI jobs we have for curl never "write back" to curl. They access the source repository read-only and even if they would be breached, they cannot infect or taint source code.

  • we run zizmor and other code analyzer tools on the CI job config scripts to reduce the risk of us running or using insecure CI jobs.

  • we do reproducible releases to allow anyone to verify that the contents is untainted

  • we digitally sign releases, git tags and git commits

  • there is a git backup on codeberg for enhanced resilience to infrastructure disturbance

  • we are committed to always fix reported vulnerabilities in the following release. Security problems never linger around once they have been reported.

  • we document everything and every detail about all curl vulnerabilities ever reported

  • our code has been audited several times by external security experts, and the few issues that have been detected in those were immediately addressed

  • Strong two-factor authentication on GitHub is mandatory for all committers

  • our commitment to never breaking ABI or API allows all users to easily upgrade to new releases. This enables users to run recent security-fixed versions instead of legacy insecure versions.

  • we have a vulnerability disclosure program that allows researchers to submit suspected vulnerabilities in a private and secure fashion, so that we can work on fixing curl and announcing the flaw in a responsible manner to minimize risks for users.

1<!--
2Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
4SPDX-License-Identifier: curl
5-->
7# Verify
9Do not trust, verify!
11## Signed releases
13Every curl release is shipped as a set of tarballs. They all have the exact
14same content but use different archivers, visible by the different file
15extensions used.
17Each tarball is signed by the curl release manager Daniel. The digital
18signatures for each tarball are always provided. The digital signatures can be
19used to verify that the tarballs were produced by Daniel.
21If the curl website were breached and fake curl releases were
22provided, they could be detected using these signatures.
24Daniel's public GPG key: [27ED EAF2 2F3A BCEB 50DB 9A12 5CC9 08FD B71E 12C2](https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x27edeaf22f3abceb50db9a125cc908fdb71e12c2)
26## Reproducible releases
28The curl project ships *reproducible releases*. This means that everyone is
29able - and encouraged - to independently verify the contents of every curl
30release. Verify that it contains exactly the bits that are supposed to be in
31the release and nothing extra.
33The curl releases are generated using a Docker image to make it easy to get an
34identical setup. To verify an existing curl release, we provide a convenient
35script that generates a new curl release from source code and then compares
36this newly generated release tarball with the tarball file you downloaded from
37curl.se.
39For full verification, invoke the script inside an up-to-date curl source code
40git repository. Without a git repository present, it does a lighter check by
41rebuilding the release using the files in the tarball.
43Note: full verification mode checks out the release tag in your repository.
44Run it in a clean working tree (no local changes) or a dedicated clone.
46Invoke it like this:
48 git clone https://github.com/curl/curl
49 cd curl
50 mv [download-dir]/curl-8.19.0.tar.xz .
51 ./scripts/verify-release curl-8.19.0.tar.xz
53A successful check ends up with a final output similar to:
55 curl-8.19.0.tar.xz: OK
57By verifying the release tarballs, you verify that Daniel does not infect the
58release on purpose or involuntarily because of anything malicious running in
59his setup.
61### Verify the verify
63Of course you should not blindly trust the verification script. It is short
64and simple and should be quick to verify. Or you write your own script that
65you trust, to do the same job.
67## Source code
69How do you then verify that what is in git is fine to build a product from?
71In the curl project we verify the source code in multiple ways, and one way to
72gain trust is to verify and review our testing procedures.
74- we have a consistent code style (invalid style causes errors)
76- we ban and avoid a number of "sensitive" and "hard-to-use" C functions (use
77 of such functions causes errors)
79- we have a ceiling for complexity in functions to keep them easy to follow,
80 read and understand (failing to do so causes errors)
82- we review all pull requests before merging, both with humans and with bots.
83 We link back commits to their origin pull requests in commit messages.
85- we ban use of "binary blobs" in git to not provide means for malicious
86 actors to bundle encrypted payloads (trying to include a blob causes errors)
88- every single file in the git repository has a clear copyright and license
89 statement. Complete knowledge and tracking of provenience.
91- we actively avoid base64 encoded chunks as they too could function as ways
92 to obfuscate malicious contents
94- we forbid and prevent git force push on the master branch. History cannot be
95 rewritten.
97- we ban most uses of UTF-8 in code and documentation to avoid easily mixed
98 up Unicode characters that look like other characters. (adding Unicode
99 characters causes errors)
101- we document everything to make it clear how things are supposed to work. No
102 surprises. Lots of documentation is tested and verified in addition to
103 spellchecks and consistent wording.
105- we have thousands of tests and we add test cases for (ideally) every
106 functionality. Finding "white spots" and adding coverage is a top priority.
107 curl runs on countless operating systems, CPU architectures and you can
108 build curl in billions of different configuration setups: not every
109 combination is practically possible to test
111- we build curl and run tests in over two hundred CI jobs that are run for
112 every commit and every PR. We do not merge commits that have unexplained
113 test failures.
115- we run all tests as "torture tests", where each test case is rerun to have
116 every invoked fallible function call fail once each, to make sure curl
117 never leaks memory or crashes due to this.
119- we build curl in CI with the most picky compiler options enabled and we
120 never allow compiler warnings to linger. We always use `-Werror` that
121 converts warnings to errors and fail the builds.
123- we run all tests using valgrind and several combinations of sanitizers to
124 find and reduce the risk for memory problems, undefined behavior and
125 similar
127- we keep running static code analyzers on the code, both traditional ones
128 (clang-tidy, CodeSonar, Coverity) but also new generation AI powered ones
129 like Zeropath and Codex Security.
131- we run fuzzing on curl: non-stop as part of Google's OSS-Fuzz project, but
132 also briefly as part of the CI setup for every commit and PR
134- we make sure that the CI jobs we have for curl never "write back" to curl.
135 They access the source repository read-only and even if they would be
136 breached, they cannot infect or taint source code.
138- we run `zizmor` and other code analyzer tools on the CI job config scripts
139 to reduce the risk of us running or using insecure CI jobs.
141- we do reproducible releases to allow anyone to verify that the contents is
142 untainted
144- we digitally sign releases, git tags and git commits
146- there is a git backup on [codeberg](https://codeberg.org/curl/) for enhanced
147 resilience to infrastructure disturbance
149- we are committed to always fix reported vulnerabilities in the following
150 release. Security problems never linger around once they have been
151 reported.
153- we document everything and every detail about all curl vulnerabilities ever
154 reported
156- our code has been audited several times by external security experts, and
157 the few issues that have been detected in those were immediately addressed
159- Strong two-factor authentication on GitHub is mandatory for all committers
161- our commitment to never breaking ABI or API allows all users to easily
162 upgrade to new releases. This enables users to run recent security-fixed
163 versions instead of legacy insecure versions.
165- we have a vulnerability disclosure program that allows researchers to submit
166 suspected vulnerabilities in a private and secure fashion, so that we can
167 work on fixing curl and announcing the flaw in a responsible manner to
168 minimize risks for users.
Diagnostics4 git calls · 40 ms
CallStatusSizeTime040 ms
discover200152 B3 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=152
git.server.agent=gitty/1.0
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch object-format
git.server.fetch=shallow filter sideband-all
git.protocol.version=2
git.pkt.frames=8
git.pkt.data=6
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=152
git.pkt.payload.max=34
ls-refs200149 B · hit3 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=149
git.response.cache=HIT
git.response.duration_ms=3
git.protocol.version=2
git.pkt.frames=3
git.pkt.data=2
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=149
git.pkt.payload.max=78
git.ls_refs.count=2
git.ls_refs.head=refs/heads/master
fetchblob:none · deepen 10200287 KiB · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=34
git.response.bytes=293470
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=blob:none
git.fetch.filter.requested=tree:0
git.fetch.filter.fallback=blob:none
git.fetch.filter.learned=false
git.fetch.wants=31c911efe5652725e930f4d2e60c9060e5f6646d
git.fetch.haves.count=0
git.fetch.deepen=10
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=10
git.pkt.data=8
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=293470
git.pkt.payload.max=65516
git.sideband.band1.bytes=293354
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=87
git.pack.bytes=293354
git.pack.ofs_delta=0
git.pack.ref_delta=1
git.pack.chain.max=1
git.pack.trailer=6a646bcda6740bab42e321b51998b52ea15146c0
git.pack.full=86
Open pack map
fetch2003.2 KiB · hit34 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=3317
git.response.cache=HIT
git.response.duration_ms=34
git.fetch.wants=c18b65a6612c8586aeb7ab0efd6e5d34072428af
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=3
git.pkt.data=2
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=3317
git.pkt.payload.max=3296
git.sideband.band1.bytes=3295
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0

Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.

Remote
https://5ad2236b39de4c8bd8f6270ea63f3ea9.artifacts.cloudflare.net/git/public-v0/curl.git
Ref
refs/heads/master
Commit
31c911efe5652725e930f4d2e60c9060e5f6646d
cf-ray
a5e23e78c84b4bc2
Request
49217010…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format