From f0052e23c246f8ea45ae74f1eb2c8ea7dc61d600 Mon Sep 17 00:00:00 2001 From: "Tammi L. Coles" Date: Mon, 13 Nov 2023 20:57:44 +0100 Subject: [PATCH 1/8] edits to data signature forms --- book/source/07-signing_data.md | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/book/source/07-signing_data.md b/book/source/07-signing_data.md index 6d9b541..c28a887 100644 --- a/book/source/07-signing_data.md +++ b/book/source/07-signing_data.md @@ -30,13 +30,14 @@ Data signature packets manifest in three distinct forms, which will be detailed ## Forms of OpenPGP data signatures -OpenPGP signatures over data can be used in three different forms[^sign-modes-gpg]: +OpenPGP data signatures can be applied in three distinct methods[^sign-modes-gpg]: -- *Detached*: The signature is a standalone artifact, separate from the signed data. -- *Inline*: The original data and the signature over data are enclosed within an OpenPGP container. -- *Cleartext signature*: A plaintext message and a signature over this message are stored in a combined text-format, maintaining the original message's readability. +- **Detached**: The OpenPGP signature exists as a separate entity, independent from the signed data. +- **Inline**: Both the original data and its corresponding OpenPGP signature are encapsulated within an OpenPGP container. +- **Cleartext signature**: A plaintext message and its OpenPGP signature coexist in a combined text format, preserving the readability of the original message. -[^sign-modes-gpg]: These three signature forms correspond with GnuPG's `--detach-sign`, `--sign` and `--clear-sign` modes. + +[^sign-modes-gpg]: These three methods of signature application align with GnuPG's `--detach-sign`, `--sign`, and `--clearsign` command options. ### Detached signatures From a76acf950b6278b7b8a977277dcd815c046f52c6 Mon Sep 17 00:00:00 2001 From: "Tammi L. Coles" Date: Mon, 13 Nov 2023 20:57:56 +0100 Subject: [PATCH 2/8] edits to data signature forms --- book/source/07-signing_data.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/book/source/07-signing_data.md b/book/source/07-signing_data.md index c28a887..4ef4aa8 100644 --- a/book/source/07-signing_data.md +++ b/book/source/07-signing_data.md @@ -30,14 +30,14 @@ Data signature packets manifest in three distinct forms, which will be detailed ## Forms of OpenPGP data signatures -OpenPGP data signatures can be applied in three distinct methods[^sign-modes-gpg]: +OpenPGP data signatures can be applied in three distinct forms[^sign-modes-gpg]: - **Detached**: The OpenPGP signature exists as a separate entity, independent from the signed data. - **Inline**: Both the original data and its corresponding OpenPGP signature are encapsulated within an OpenPGP container. - **Cleartext signature**: A plaintext message and its OpenPGP signature coexist in a combined text format, preserving the readability of the original message. -[^sign-modes-gpg]: These three methods of signature application align with GnuPG's `--detach-sign`, `--sign`, and `--clearsign` command options. +[^sign-modes-gpg]: These three forms of signature application align with GnuPG's `--detach-sign`, `--sign`, and `--clearsign` command options. ### Detached signatures From 7e89a9f11f4224eba727e30b45309f43069a42a3 Mon Sep 17 00:00:00 2001 From: "Tammi L. Coles" Date: Mon, 13 Nov 2023 21:18:15 +0100 Subject: [PATCH 3/8] remove blank line --- book/source/07-signing_data.md | 1 - 1 file changed, 1 deletion(-) diff --git a/book/source/07-signing_data.md b/book/source/07-signing_data.md index 4ef4aa8..28dcaba 100644 --- a/book/source/07-signing_data.md +++ b/book/source/07-signing_data.md @@ -36,7 +36,6 @@ OpenPGP data signatures can be applied in three distinct forms[^sign-modes-gpg]: - **Inline**: Both the original data and its corresponding OpenPGP signature are encapsulated within an OpenPGP container. - **Cleartext signature**: A plaintext message and its OpenPGP signature coexist in a combined text format, preserving the readability of the original message. - [^sign-modes-gpg]: These three forms of signature application align with GnuPG's `--detach-sign`, `--sign`, and `--clearsign` command options. ### Detached signatures From ee65b80bc7eebd5a2171df9e8b9ba96b1ba23b25 Mon Sep 17 00:00:00 2001 From: "Tammi L. Coles" Date: Mon, 13 Nov 2023 21:20:09 +0100 Subject: [PATCH 4/8] default to data signatures not signature over data --- book/source/07-signing_data.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/book/source/07-signing_data.md b/book/source/07-signing_data.md index 28dcaba..f6c2b7b 100644 --- a/book/source/07-signing_data.md +++ b/book/source/07-signing_data.md @@ -15,7 +15,7 @@ it does not automatically signal if the expected party indeed controls the signe Data signatures can only be issued by component keys with the *signing* [key flag](https://www.ietf.org/archive/id/draft-ietf-openpgp-crypto-refresh-12.html#name-key-flags). -Note that signatures over data are distinct from {ref}`component_signatures_chapter`, which are used to attach metadata or subkeys to a certificate. +Note that data signatures are distinct from {ref}`component_signatures_chapter`, which are used to attach metadata or subkeys to a certificate. ## Signature types From 62af0cb83b8ede55913fa7dad98825157c5d3514 Mon Sep 17 00:00:00 2001 From: "Tammi L. Coles" Date: Mon, 13 Nov 2023 21:27:37 +0100 Subject: [PATCH 5/8] edit ch7 detached signatures --- book/source/07-signing_data.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/book/source/07-signing_data.md b/book/source/07-signing_data.md index f6c2b7b..eb4a596 100644 --- a/book/source/07-signing_data.md +++ b/book/source/07-signing_data.md @@ -40,9 +40,9 @@ OpenPGP data signatures can be applied in three distinct forms[^sign-modes-gpg]: ### Detached signatures -A detached signature is produced by calculating an OpenPGP signature over the signed data. The original data is left as is, while the OpenPGP signature is stored as a standalone file. A detached signature can be distributed alongside or independent of the original data. The authenticity and integrity of the original data file can be verified using the detached signature file. +A detached signature is produced by calculating an OpenPGP signature over the data intended for signing. The original data remains unchanged, and the OpenPGP signature is stored as a standalone file. A detached signature file can be distributed alongside or independent of the original data. The authenticity and integrity of the original data file can be verified by using the detached signature file. -This signature format is especially useful for signing software releases and other files that must not be modified by the signing process. +This signature format is especially useful for signing software releases and other files where it is imperative that the content remains unaltered during the signing process. ### Inline signatures From 17d43e0e91485e44c127a2f6b62ea1505e08f70d Mon Sep 17 00:00:00 2001 From: "Tammi L. Coles" Date: Mon, 13 Nov 2023 21:33:03 +0100 Subject: [PATCH 6/8] edit ch7 inline signatures --- book/source/07-signing_data.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/book/source/07-signing_data.md b/book/source/07-signing_data.md index eb4a596..3fd5d5e 100644 --- a/book/source/07-signing_data.md +++ b/book/source/07-signing_data.md @@ -46,9 +46,9 @@ This signature format is especially useful for signing software releases and oth ### Inline signatures -An inline signature joins the signed data and a signature over this data into one combined OpenPGP message. +An inline signature joins the signed data and its corresponding data signature into a single OpenPGP message. -This method is usually used with signed and/or encrypted emails. Most software that supports OpenPGP for encrypted and/or signed messages uses inline-signatures. +This method is commonly used for signing or encrypting emails. Most email software capable of handling OpenPGP communications typically uses inline signatures. #### Structure From e6b9c11a3dabce9564b0c9732be731c70e6f53be Mon Sep 17 00:00:00 2001 From: "Tammi L. Coles" Date: Mon, 13 Nov 2023 22:06:35 +0100 Subject: [PATCH 7/8] edit ch7 inline signatures --- book/source/07-signing_data.md | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/book/source/07-signing_data.md b/book/source/07-signing_data.md index 3fd5d5e..618e80f 100644 --- a/book/source/07-signing_data.md +++ b/book/source/07-signing_data.md @@ -54,15 +54,18 @@ This method is commonly used for signing or encrypting emails. Most email softwa An inline-signed OpenPGP message consists of three segments: -- One or more [One-Pass Signature packets](https://www.ietf.org/archive/id/draft-ietf-openpgp-crypto-refresh-12.html#one-pass-sig), -- the original data, wrapped in a [Literal Data packet](https://www.ietf.org/archive/id/draft-ietf-openpgp-crypto-refresh-12.html#lit), -- the corresponding Data Signature packets. +1. **One-pass signature packets**: These one or more packets precede the signed data and enable signature computation in one pass. See[One-Pass Signature Packet (Type ID 4)](https://www.ietf.org/archive/id/draft-ietf-openpgp-crypto-refresh-12.html#one-pass-sig) of the RFC. + +2. **Literal data**: This is the original data (e.g., the body of a message) that the user wishes to encrypt or sign, without additional interpretation or conversion. [Literal Data Packet (Type ID 11)](https://www.ietf.org/archive/id/draft-ietf-openpgp-crypto-refresh-12.html#lit). + +3. **Data signature packets**: These contain the cryptographic signature corresponding to the original data. + #### Creation -To produce an inline signature, the signer processes the entirety of the data by reading from an input file and writing into am output OpenPGP message file. The signer calculates a cryptographic signature over the course of this process. Therefore, an efficient signer can only emit the resulting data signature packet at the end of this process, and thus store it at the end of the data stream. +To produce an inline signature, the signer processes the entirety of the data by reading from an input file and writing into am output OpenPGP message file. As the data is processed, the signer simultaneously calculates a cryptographic signature. This procedure results in a data signature packet being appended to the output OpenPGP message file, an essential step for efficient signing. -On the other hand, an efficient verifying application needs to know how to process the literal data before reading it. This is the purpose of the so-called One-Pass Signature packets in the first segment of inline-signed messages. One-Pass Signature packets contain the fingerprint of the signing key, as well as the hash algorithm used to calculate the hash digest for the signature. +For efficient verification, an application must understand how to handle the literal data prior to its reading. This requirement is addressed by the One-Pass Signature packets located at the beginning of inline-signed messages. These packets include essential information such as the fingerprint of the signing key and the hash algorithm used for computing the signature's hash digest. This setup enables the verifier to process the data correctly and efficiently. ```{admonition} TODO :class: warning @@ -72,13 +75,15 @@ Is the signer keyid/fingerprint in the OPS important for the verifier to be able #### Verification -This structure allows verifying applications to verify inline-signed messages in *one pass*: +Inline-signed messages enable efficient verification in *one pass*, structured as follows: -- The One-Pass Signature packets initiate the verification process, -- the literal data can then be processed (which means: it gets hashed), -- the signature packets at the end of the message can be verified against the hash digest that the previous step calculated. +1. **Initiation with One-Pass Signature packets**: These packets begin the verification process. They include the signer's key ID/fingerprint, essential for identifying the appropriate public key for signature validation. + +2. **Processing the literal data**: This step involves hashing the literal data, preparing it for signature verification. -Note that the final step of verifying the cryptographic signature requires access to the signer's public key material. This public key material is not included in the signed message. The verifier must obtain the signer's public key data out-of-band (e.g. by obtaining the signer's certificate from a key server). +3. **Verifying signature packets**: Located at the end of the message, these packets are checked against the previously calculated hash digest. + +Important to note, the signer's public key, critical for the final verification step, is not embedded in the message. Verifiers must acquire this key externally (e.g., from a key server) to authenticate the signature successfully. ### Cleartext signatures From 78c8327733438d3f16bec731a926701dec7be062 Mon Sep 17 00:00:00 2001 From: "Tammi L. Coles" Date: Mon, 13 Nov 2023 22:36:05 +0100 Subject: [PATCH 8/8] edit ch7 cleartext signature --- book/source/07-signing_data.md | 24 ++++++++---------------- 1 file changed, 8 insertions(+), 16 deletions(-) diff --git a/book/source/07-signing_data.md b/book/source/07-signing_data.md index 618e80f..0c342a5 100644 --- a/book/source/07-signing_data.md +++ b/book/source/07-signing_data.md @@ -87,14 +87,14 @@ Important to note, the signer's public key, critical for the final verification ### Cleartext signatures -The *Cleartext Signature Framework* (CSF) is an OpenPGP mechanism that combines two goals: +The *Cleartext Signature Framework* (CSF) in OpenPGP accomplishes two primary objectives: -- It leaves the message in clear text format, so that it can be viewed directly by a human in a program that knows nothing about OpenPGP. -- At the same time, it adds an OpenPGP signature that allows verification of that message by users whose software supports OpenPGP. +- maintaining the message in a human-readable cleartext format, accessible without OpenPGP-specific software +- incorporating an OpenPGP signature for authentication by users with OpenPGP-compatible software #### Example -In {numref}`cleartext` we inspect an example of a cleartext signature in detail. Let's have a brief look at this example, here, to get a sense of what a cleartext signature looks like: +Below is a detailed example of a {numref}`cleartext` signature: ```text -----BEGIN PGP SIGNED MESSAGE----- @@ -111,15 +111,11 @@ r13/eqMN8kfCDw== -----END PGP SIGNATURE----- ``` -The cleartext signature consists of two blocks, which contain the message and a signature, respectively. In this case, the message consists of the text "hello world". +This signature is split into two parts: a message ("hello world") and an ASCII-armored OpenPGP signature. The message is immediately comprehensible to a human reader, while the signature block allows for the message's authenticity verification via OpenPGP software. -Notice that this message is readable by a human reader, without requiring additional software tools, as long as the reader understands which elements to ignore. +#### Use case -The message is followed by a block that contains an ASCII-armored OpenPGP signature for the message. Using this signature, OpenPGP software can verify the authenticity of the message in the first block. - -#### Use-case - -One use-case for cleartext signatures is: Asking someone to sign some piece of data. The person who is asked to sign the data can easily inspect it with simple commandline tools, such as `cat`, and verify that they agree with the data they are asked to sign. +A common use case is requesting someone to sign data. The signer can easily inspect the data using simple command line tools (e.g., `cat`) to verify that they agree with the content of the data before deciding to sign it. ```{admonition} TODO :class: warning @@ -139,14 +135,10 @@ explain text transformations for cleartext signatures (LF->CRLF and additional e #### Pitfalls -Cleartext signatures are popular and have useful applications. - -At the same time, they are considered a "legacy method"[^csf-gnupg] by some. +While widely used, cleartext signatures are sometimes considered a "legacy method"[^csf-gnupg]. The RFC outlines [pitfalls of cleartext signatures](https://www.ietf.org/archive/id/draft-ietf-openpgp-crypto-refresh-12.html#name-issues-with-the-cleartext-s) and advises that inline and detached signature forms are often preferable. [^csf-gnupg]: https://lists.gnupg.org/pipermail/gnupg-devel/2023-November/035428.html -The RFC points out a number of specific [pitfalls of cleartext signatures](https://www.ietf.org/archive/id/draft-ietf-openpgp-crypto-refresh-12.html#name-issues-with-the-cleartext-s), and how to avoid them. It advises that in many cases, the inline and detached signature forms are preferable. - ## Advanced topics ### Nesting of one-pass signatures