Merge pull request 'Move binding text to ch6' (#72) from heiko-ch4-shorten-binding-text into draft

Reviewed-on: https://codeberg.org/openpgp/notes/pulls/72

book/source/04-certificates.md

@@ -23,7 +23,7 @@ The following section will delve into the OpenPGP-specific layers (2 and 3) to p
 
 For detailed insights on structure and handling, refer to our chapters on OpenPGP [certificates](certificates_chapter) and [private keys](private_key_chapter). Additionally, managing certificates, and understanding their authentication and trust models are vital topics. While this document briefly touches upon these aspects, they are integral to working proficiently with OpenPGP.
 
-## Structure of OpenPGP certificates
+## Components of an OpenPGP certificate
 
 An OpenPGP certificate (or "OpenPGP key") is a collection of an arbitrary number of elements[^packets]:
 
@@ -145,7 +145,7 @@ Identity components in an OpenPGP certificate are used by the certificate holder
 
 An OpenPGP certificate can contain any number of [User IDs](https://www.ietf.org/archive/id/draft-ietf-openpgp-crypto-refresh-10.html#name-user-id-packet-tag-13). Each User ID associates the certificate with an identity.
 
-```{figure} diag/user_id.png
+```{figure} diag/user_ids.png
 
 OpenPGP certificates can contain any number of User IDs
 ```
@@ -176,80 +176,17 @@ we might need to write a more nuanced text here, about how DKS and primary user
 
 The OpenPGP standard currently only defines one format to store in User Attributes: an [image](https://www.ietf.org/archive/id/draft-ietf-openpgp-crypto-refresh-10.html#name-the-image-attribute-subpack), "presumably (but not required to be) that of the key owner".
 
-### Linking the components of an OpenPGP certificate
+## Linking the components
 
-So far we've looked at the components in an OpenPGP certificate, but certificates actually contain another set of elements, which bind the components together, and add metadata to them.
+To form an OpenPGP certificate out of a collection of components, the certificate holder links these components together (using their OpenPGP software).
 
-Internally, an OpenPGP certificate consists of a sequence of OpenPGP packets. These packets are just stringed together, one after the other. When a certificate is stored in a file[^tpk], it's easy to remove some of these packets, or add new ones.
+The OpenPGP term for linking components is "binding," as in: "a subkey is bound to the primary key." The bindings are realized using cryptographic signatures (much more details about this are in {ref}`certifications_chapter`).
 
-[^tpk]: When stored in a file, OpenPGP certificates are in a format called [transferable public key](https://www.ietf.org/archive/id/draft-ietf-openpgp-crypto-refresh-10.html#name-transferable-public-keys).
+In very abstract terms, the primary key of a certificate acts as a root of trust for that certificate (as a kind of "certification authority"):
 
-However, the owner of a certificate doesn't want a third party to add subkeys (or add [identity components](identity_components)) to their certificate, pretending that the certificate owner put those components there.
+The primary key issues signatures that express the certificate holder's intent to use subkeys or identity components. It also performs other lifecycle operations, such as setting expiration times, or marking components as invalidated ("revoked").
-
-To prevent malicious addition of components, OpenPGP uses cryptographic signatures. These signatures show that components have been added by the owner of the OpenPGP certificate (these linking signatures are issued by the primary key of the certificate).
-
-So while anyone can still unilaterally store unrelated subkeys and [identity components](identity_components) in an OpenPGP certificate dataset, OpenPGP implementations that read this certificate should discard components that don't have a valid cryptographic connection with the certificate.
-
-(Conversely, it's easy for a third party to leave out packets when passing on an OpenPGP certificate. An attacker can, for example, choose to omit revocation packets. The recipient of such a partial copy has no way to notice the omission, without access to a different source for the certificate that contains the revocation packet.)
-
-Note, though, that there are some cases where third parties legitimately add "unbound" packets to certificates (that is: packets that are not signed by the certificate's owner):
-
-- [Third-party certifications](third_party_cert) are traditionally added to the certificate that they make a statement about (this can cause problems in systems that unconditionally accept and include such certifications[^flooding]),
-- OpenPGP software may add [unbound identity data](unbound_user_ids), locally.
-
-[^flooding]: Storing third-party identity certifications in the target OpenPGP certificate is convenient for consumers: it is easy to find all relevant certifications in one central location. However, when third parties can unilaterally add certifications, this opens an avenue for denial-of-service attacks by flooding. The SKS network of OpenPGP key servers [allowed and experienced this problem](https://dkg.fifthhorseman.net/blog/openpgp-certificate-flooding.html).
-
-(binding_subkeys)=
-#### Binding subkeys to an OpenPGP certificate
-
-Linking a subkey to an OpenPGP certificate is done with a ["Subkey Binding Signature"](https://www.ietf.org/archive/id/draft-ietf-openpgp-crypto-refresh-10.html#sigtype-subkey-binding). Such a signature signals that the "primary key wants to be associated with the subkey".
-
-The subkey binding signature also adds metadata.
-
-```{figure} diag/subkey_binding.png
-
-Linking an OpenPGP subkey to the primary key with a binding signature
-```
-
-The [Signature packet](https://www.ietf.org/archive/id/draft-ietf-openpgp-crypto-refresh-10.html#name-signature-packet-tag-2) that binds the subkey to the primary key has the signature type [SubkeyBinding](https://www.ietf.org/archive/id/draft-ietf-openpgp-crypto-refresh-10.html#name-subkey-binding-signature-si).
-
-##### Binding signing subkeys to an OpenPGP certificate
-
-Binding subkeys with the "signing" key flag is a special case:
-
-When binding a signing subkey to a primary key, it is not sufficient that the "primary key wants to be associated with the subkey." In addition, the subkey must signal that it "wants to be associated with that primary key."
-
-Otherwise, Alice could "adopt" Bob's signing subkey and convincingly claim that she made signatures that were in fact issued by Bob.
-
-```{figure} diag/subkey_binding_backsig.png
-
-Linking an OpenPGP signing subkey to the primary key with a binding signature, and an embedded primary key binding signature
-```
-
-This additional "Primary Key Binding" Signature is informally called a "back signature" (because the subkey uses the signature to point "back" to the primary key).
-
-
-#### Binding identities with certifying self-signatures
-
-"User ID" identity components are bound to an OpenPGP certificate by issuing a self-signature ("User Attributes" work analogously).
-
-For example, the User ID `Alice Adams <alice@example.org>` may be associated with Alice's certificate `AAA1 8CBB 2546 85C5 8358 3205 63FD 37B6  7F33 00F9 FB0E C457 378C D29F 1026 98B3`.
-
-Alice can link a User ID to her OpenPGP certificate with a cryptographic signature. To link a User ID, a self-signature is created (usually with the signature type [PositiveCertification](https://www.ietf.org/archive/id/draft-ietf-openpgp-crypto-refresh-10.html#sigtype-positive-cert)). This signature is issued by the primary key.
-
-```{figure} diag/user_id_certification.png
----
----
-Linking a User ID to an OpenPGP certificate
-```
-
-(direct_key_signature)=
-#### Direct key signature
-
-```{admonition} TODO
-explain metadata associated with this signature, and that c-r prefers this over primary user id.
-```
 
+Binding components together with digital signatures means that recipients of an OpenPGP certificate only need to verify that the primary key is the correct one to use for their communication partner (traditionally, this has often been done by manually verifying the *fingerprint* of the primary key). Once the validity of the primary key is established, the validity of all other components can be automatically determined by the user's OpenPGP software. To a first estimation, components are valid parts of a certificate if there is a statement signed with the certificate's primary key that expresses this validity.
 
 ### Revocations
 
@@ -272,6 +209,12 @@ Note: certification signatures [can be made irrevocable](https://www.ietf.org/ar
 This section needs writing
 ```
 
+
+In the past, the SKS keyserver network has accepted third party signatures and added them to certificates without any limitations. This has caused problems: anyone can add a large number of certifications to some certificates, which opens the door to a type of "vandalism", by growing certificates unreasonably, and making them annoying to use[^flooding].
+
+[^flooding]: Storing third-party identity certifications in the target OpenPGP certificate is convenient for consumers: it is easy to find all relevant certifications in one central location. However, when third parties can unilaterally add certifications, this opens an avenue for denial-of-service attacks by flooding. The SKS network of OpenPGP key servers [allowed and experienced this problem](https://dkg.fifthhorseman.net/blog/openpgp-certificate-flooding.html).
+
+
 ## Advanced topics
 
 ```{admonition} TODO