merge upstream master

Author: HC-Chang

_posts/2020-04-13-Disk-Encryption.md

@@ -107,6 +107,7 @@ Create the RSA key<br>
 1. `tpm2_createprimary --hierarchy=o --key-algorithm=rsa --key-context=prim.ctx`<br>
 
 Save it to the TPM persistent memory<br>
+{:start="2"}<br>
 2. `tpm2_evictcontrol --hierarchy=o --object-context=prim.ctx 0x81010001`<br>
 
 NOTE:
@@ -139,6 +140,7 @@ first setup a disk image without encryption and see if we can extract user
 generated content.<br>
 
 Create a disk image and write some content:<br>
+{:start="3"}<br>
 3. `dd if=/dev/zero of=plain.disk bs=1M count=10`<br>
 4. `mkfs.ext4 plain.disk`<br>
 5. `mkdir -p mountpoint`<br>
@@ -155,7 +157,7 @@ find the plain.txt. To do this simply do the following:<br>
 11. `strings plain.disk`<br>
 
 NOTE:
-* Having a week authentication mechanism for login control is not mitigated by
+* Having a weak authentication mechanism for login control is not mitigated by
 disk encryption. Mounted encrypted volumes without user intervention are
 available in clear to the logged in user.
 * Data assets especially storage must remain confidential either with disk/ file
@@ -183,11 +185,13 @@ Let's setup a new LUKS volume with a simple passphrase as key protector:<br>
 At this point you have setup the luks volume and it should pop a warning about
 overriding the data. Next let's open the LUKS volume by authenticating with the
 disk.key and complete the setting up the disk with a filesystem.<br>
+{:start="16"}<br>
 16. `sudo cryptsetup luksOpen --key-file=disk.key $loopdevice enc_volume`<br>
 17. `sudo mkfs.ext4 -j /dev/mapper/enc_volume`<br>
 18. `sudo mount /dev/mapper/enc_volume mountpoint`<br>
 
 Now lets create a plain text file again and add user content to it:<br>
+{:start="19"}<br>
 19. `sudo touch mountpoint/plain.txt`<br>
 20. `sudo chmod 777 mountpoint/plain.txt`<br>
 21. `sudo echo "This is my plain text" > mountpoint/plain.txt`<br>
@@ -197,6 +201,7 @@ Now lets create a plain text file again and add user content to it:<br>
 
 You will now see that you cannot dump the information from the disk image simply
 : <br>
+{:start="25"}<br>
 25. `strings enc.disk | grep -i plain`<br>
 
 NOTE:
@@ -217,35 +222,33 @@ Solution:<br>
 a. Seal the secret into a TPM device.<br>
 b. Unseal the secret in memory and pass it to cryptsetup.<br>
 
-Please note that there is an upstreaming effort in the cryptsetup
-[feature-branch](https://gitlab.com/cryptsetup/cryptsetup/-/tree/wip-tpm) to
-enable tpm2 as a key protector built natively in to libcryptsetup as well as
-cryptsetup. It does so by adding a new keyslot-handler internally and extending
-the libcryptsetup API. In this tutorial however, we will be using tpm2-tools
-with cryptsetup that does not have built-in tpm2 support.<br>
-
 Let's start with creating and persisting a sealing object and sealing a random
 byte sequence as the disk key.<br>
+{:start="26"}<br>
 26. `tpm2_createprimary -Q -C o -c prim.ctx`<br>
 27. `dd if=/dev/urandom bs=1 count=32 status=none | tpm2_create -Q -g sha256 -u seal.pub -r seal.priv -i- -C prim.ctx`<br>
 28. `tpm2_load -Q -C prim.ctx -u seal.pub -r seal.priv -n seal.name -c seal.ctx`<br>
 29. `tpm2_evictcontrol -C o -c seal.ctx 0x81010001`<br>
 
 Now lets change the authentication from previously created disk.key to the new
 sealed secret and after that shred the disk.key since it's no longer useful:<br>
+{:start="30"}
 30. `tpm2_unseal -Q -c 0x81010001 | sudo cryptsetup luksChangeKey enc.disk --key-file disk.key`<br>
 31. `shred disk.key; rm -f disk.key`<br>
 
 Now let's mount the volume with the new authentication sealed up in the tpm:<br>
+{:start="32"}<br>
 32. `sudo losetup $loopdevice enc.disk`<br>
 33. `tpm2_unseal -Q -c 0x81010001 |sudo cryptsetup luksOpen --key-file=- $loopdevice enc_volume`<br>
 34. `sudo mount /dev/mapper/enc_volume mountpoint`<br>
 
 You can now see that disk access is granted with the new secret:<br>
+{:start="35"}<br>
 35. `ls mountpoint`
 <br>
 
 Finally unmount the disk:<br>
+{:start="36"}<br>
 36. `sudo umount mountpoint`<br>
 37. `sudo cryptsetup remove enc_volume`<br>
 38. `sudo losetup -d $loopdevice`<br>
@@ -280,13 +283,15 @@ c. After unsealing the pass-phrase; extend the sealing PCRs so that the
 pass-phrase cannot be unsealed gain.<br>
 
 Let's begin with creating a pcr policy with current value in PCR0 sha256 bank<br>
+{:start="39"}<br>
 39. `tpm2_startauthsession -S session.ctx`<br>
 40. `tpm2_policypcr -Q -S session.ctx -l sha256:0 -L pcr0.sha256.policy`<br>
 41. `tpm2_flushcontext session.ctx`<br>
 
 Now replace the seal object in TPM NV memory protecting the disk encryption
 secret with a new one that adds the pcr policy we just created as an
 authentication mechanism to access the sealed secret.<br>
+{:start="42"}<br>
 42. `tpm2_unseal -c 0x81010001 | tpm2_create -Q -g sha256 -u pcr_seal_key.pub -r pcr_seal_key.priv -i- -C prim.ctx -L pcr0.sha256.policy `<br>
 43. `tpm2_evictcontrol -C o -c 0x81010001`<br>
 44. `tpm2_load -Q -C prim.ctx -u pcr_seal_key.pub  -r pcr_seal_key.priv -n pcr_seal_key.name -c pcr_seal_key.ctx`<br>
@@ -296,6 +301,7 @@ Now let's try to mount the encrypted disk again but this time the secret is
 unsealed off a TPM object whose unsealing operation can only be accessed by
 satisfying the PCR policy; in other words authenticating by virtue of intended
 system software state being unchanged as reflected by the PCR value.<br>
+{:start="46"}<br>
 46. `sudo losetup $loopdevice enc.disk`<br>
 47. `tpm2_startauthsession --policy-session -S session.ctx `<br>
 48. `tpm2_policypcr -Q -S session.ctx -l sha256:0`<br>
@@ -306,6 +312,7 @@ directly to the cryptsetup app like this --> "tpm2_unseal -p session:session.ctx
 However for the purpose of demonstrating flexible PCR in a later section we will
 make a copy of the unsealed secret at this point to seal it with a new object
 with flexible pcr policy. This breakdown to two steps<br>
+{:start="49"}<br>
 49. `tpm2_unseal -p session:session.ctx -c 0x81010001 > disk_secret.bkup`<br>
 50. `cat disk_secret.bkup | sudo cryptsetup luksOpen --key-file=- $loopdevice enc_volume`<br>
 51. `tpm2_flushcontext session.ctx `<br>
@@ -321,16 +328,19 @@ consequence of failed policy check and thus a failed unsealing attempt.<br>
 
 Let's look at the PCR state prior to extending it and then again after
 extending: <br>
+{:start="54"}<br>
 54. `tpm2_pcrlist -l sha256:0`<br>
 55. `tpm2_pcrextend 0:sha256=0000000000000000000000000000000000000000000000000000000000000000`<br>
 56. `tpm2_pcrlist -l sha256:0`<br>
 
 Now let's try to unseal the sealed disk encryption secret with the dirty
 PCR:<br>
+{:start="57"}<br>
 57. `tpm2_startauthsession --policy-session -S session.ctx `<br>
 58. `tpm2_policypcr -Q -S session.ctx -l sha256:0`<br>
 The following operation should result in policy check failure preventing the
 unseal operation:<br>
+{:start="59"}<br>
 59. `tpm2_unseal -p session:session.ctx -c 0x81010001`<br>
 60. `tpm2_flushcontext session.ctx`<br>
 
@@ -355,6 +365,7 @@ PCR signature. The PCR sets are signed by the system designer and verified by
 the TPM. This is achieved in following steps:
 
 __a. Get the new set of PCR and sign the pcr policy with signer private key.__<br>
+{:start="61"}<br>
 61. `tpm2_startauthsession -S session.ctx`<br>
 62. `tpm2_policypcr -Q -S session.ctx -l sha256:0 -L set2.pcr.policy`<br>
 63. `tpm2_flushcontext session.ctx`<br>
@@ -363,9 +374,11 @@ __a. Get the new set of PCR and sign the pcr policy with signer private key.__<b
 
 We now need the name which is a digest of the TCG public key format of the
 public key to include in the policy. We can use the loadexternal tool for this:<br>
+{:start="66"}<br>
 66. `tpm2_loadexternal -G rsa -C o -u signing_key_public.pem -c signing_key.ctx -n signing_key.name`<br>
 
 Let's now create the signer policy:<br>
+{:start="67"}<br>
 67. `tpm2_startauthsession -S session.ctx`<br>
 68. `tpm2_policyauthorize -S session.ctx -L authorized.policy -n signing_key.name -i set2.pcr.policy`<br>
 69. `tpm2_flushcontext session.ctx`<br>
@@ -374,10 +387,12 @@ Let's create a new sealing object with the authorized policy which will also
 require the sealing secret for which we will use the disk_secret.bkup we created
 at #49 earlier to avoid rebooting the platform to match the PCR we originally
 had prior to extending.<br>
+{:start="70"}<br>
 70. `cat disk_secret.bkup | tpm2_create -g sha256 -u auth_pcr_seal_key.pub -r auth_pcr_seal_key.priv -i- -C prim.ctx -L authorized.policy`<br>
 
 Let's replace the old persistent sealing object with the one we created
 above with policy_authorize policy associated with signer public key:<br>
+{:start="71"}<br>
 71. `tpm2_evictcontrol -C o -c 0x81010001`<br>
 72. `tpm2_load -Q -C prim.ctx -u auth_pcr_seal_key.pub  -r auth_pcr_seal_key.priv -n auth_pcr_seal_key.name -c auth_pcr_seal_key.ctx`<br>
 73. `tpm2_evictcontrol -c auth_pcr_seal_key.ctx 0x81010001 -C o`<br>
@@ -386,15 +401,18 @@ Let's now sign the pcr_policy with the signer private key:<br>
 
 __b. Load the signer public key to the tpm and verify the signature on the pcr 
 and get the tpm verification tkt:__<br>
+{:start="75"}<br>
 75. `tpm2_loadexternal -G rsa -C o -u signing_key_public.pem -c signing_key.ctx -n signing_key.name`<br>
 76. `tpm2_verifysignature -c signing_key.ctx -g sha256 -m set2.pcr.policy  -s set2.pcr.signature -t verification.tkt -f rsassa`<br>
 
 __c. Satisfy the authorized policy and then run policyauthorize:__<br>
+{:start="77"}<br>
 77. `tpm2_startauthsession --policy-session -S session.ctx`<br>
 78. `tpm2_policypcr -l sha256:0 -S session.ctx`<br>
 79. `tpm2_policyauthorize -S session.ctx -i set2.pcr.policy -n signing_key.name -t verification.tkt`<br>
 
 __d. Pipe unseal output to the cryptsetup application:__<br>
+{:start="80"}<br>
 80. `sudo losetup $loopdevice enc.disk`<br>
 81. `tpm2_unseal -p session:session.ctx -c 0x81010001 | sudo cryptsetup luksOpen --key-file=- $loopdevice enc_volume`<br>
 82. `tpm2_flushcontext session.ctx `<br>