tests/generic/399

   1 #! /bin/bash
   2 # SPDX-License-Identifier: GPL-2.0
   3 # Copyright (c) 2016 Google, Inc.  All Rights Reserved.
   4 #
   5 # FS QA Test generic/399
   6 #
   7 # Check for weaknesses in filesystem encryption involving the same ciphertext
   8 # being repeated.  For file contents, we fill a small filesystem with large
   9 # files of 0's and verify the filesystem is incompressible.  For filenames, we
  10 # create an identical symlink in two different directories and verify the
  11 # ciphertext filenames and symlink targets are different.
  12 #
  13 # This test can detect some basic cryptographic mistakes such as nonce reuse
  14 # (across files), initialization vector reuse (across blocks), or data somehow
  15 # being left in plaintext by accident.  For example, it detects the
  16 # initialization vector reuse bug fixed in commit 02fc59a0d28f ("f2fs/crypto:
  17 # fix xts_tweak initialization").
  18 #
  19 seq=`basename $0`
  20 seqres=$RESULT_DIR/$seq
  21 echo "QA output created by $seq"
  22
  23 here=`pwd`
  24 tmp=/tmp/$$
  25 status=1        # failure is the default!
  26 trap "_cleanup; exit \$status" 0 1 2 3 15
  27
  28 _cleanup()
  29 {
  30         cd /
  31         rm -f $tmp.*
  32 }
  33
  34 # get standard environment, filters and checks
  35 . ./common/rc
  36 . ./common/filter
  37 . ./common/encrypt
  38
  39 # remove previous $seqres.full before test
  40 rm -f $seqres.full
  41
  42 # real QA test starts here
  43 _supported_fs generic
  44 _supported_os Linux
  45 _require_scratch_encryption
  46 _require_command "$XZ_PROG" xz
  47 _require_command "$KEYCTL_PROG" keyctl
  48
  49 _new_session_keyring
  50
  51 #
  52 # Set up a small filesystem containing an encrypted directory.  64 MB is enough
  53 # for both ext4 and f2fs (f2fs doesn't support a 32 MB filesystem).  Before
  54 # creating the filesystem, zero out the needed portion of the device so that
  55 # existing data on the device doesn't contribute to the compressed size.
  56 #
  57 fs_size_in_mb=64
  58 fs_size=$((fs_size_in_mb * 1024 * 1024))
  59 dd if=/dev/zero of=$SCRATCH_DEV bs=$((1024 * 1024)) \
  60         count=$fs_size_in_mb &>> $seqres.full
  61 _scratch_mkfs_sized_encrypted $fs_size &>> $seqres.full
  62 _scratch_mount
  63
  64 keydesc=$(_generate_encryption_key)
  65 mkdir $SCRATCH_MNT/encrypted_dir
  66 _set_encpolicy $SCRATCH_MNT/encrypted_dir $keydesc
  67
  68 # Create the "same" symlink in two different directories.
  69 # Later we'll check both the name and target of the symlink.
  70 mkdir $SCRATCH_MNT/encrypted_dir/subdir1
  71 mkdir $SCRATCH_MNT/encrypted_dir/subdir2
  72 ln -s symlink_target $SCRATCH_MNT/encrypted_dir/subdir1/symlink
  73 ln -s symlink_target $SCRATCH_MNT/encrypted_dir/subdir2/symlink
  74
  75 #
  76 # Write files of 1 MB of all the same byte until we hit ENOSPC.  Note that we
  77 # must not create sparse files, since the contents of sparse files are not
  78 # stored on-disk.  Also, we create multiple files rather than one big file
  79 # because we want to test for reuse of per-file keys.
  80 #
  81 total_file_size=0
  82 i=1
  83 while true; do
  84         file=$SCRATCH_MNT/encrypted_dir/file$i
  85         if ! $XFS_IO_PROG -f $file -c 'pwrite 0 1M' &> $tmp.out; then
  86                 if ! grep -q 'No space left on device' $tmp.out; then
  87                         echo "FAIL: unexpected pwrite failure"
  88                         cat $tmp.out
  89                 elif [ -e $file ]; then
  90                         total_file_size=$((total_file_size + $(stat -c %s $file)))
  91                 fi
  92                 break
  93         fi
  94         total_file_size=$((total_file_size + $(stat -c %s $file)))
  95         i=$((i + 1))
  96         if [ $i -gt $fs_size_in_mb ]; then
  97                 echo "FAIL: filesystem never filled up!"
  98                 break
  99         fi
 100 done
 101
 102 # We shouldn't have been able to write more data than we had space for.
 103 if (( $total_file_size > $fs_size )); then
 104         echo "FAIL: wrote $total_file_size bytes but should have only" \
 105                 "had space for $fs_size bytes at most"
 106 fi
 107
 108 #
 109 # Unmount the filesystem and compute its compressed size.  It must be no smaller
 110 # than the amount of data that was written; otherwise there was a compromise in
 111 # the confidentiality of the data.  False positives should not be possible
 112 # because filesystem metadata will also contribute to the compressed size.
 113 #
 114 # Note: it's important to use a strong compressor such as xz which can detect
 115 # redundancy across most or all of the filesystem.  We run xz with a 64 MB
 116 # sliding window but use some custom settings to make it faster and use less
 117 # memory than the '-9' preset.  The memory needed with our settings will be
 118 # 64 * 6.5 = 416 MB; see xz(1).
 119 #
 120 _unlink_encryption_key $keydesc
 121 _scratch_unmount
 122 fs_compressed_size=$(head -c $fs_size $SCRATCH_DEV | \
 123         xz --lzma2=dict=64M,mf=hc4,mode=fast,nice=16 | \
 124         wc -c)
 125
 126 if (( $fs_compressed_size < $total_file_size )); then
 127         echo "FAIL: filesystem was compressible" \
 128                 "($total_file_size bytes => $fs_compressed_size bytes)"
 129 else
 130         echo "PASS: ciphertexts were not repeated for contents"
 131 fi
 132
 133 # Verify that encrypted filenames and symlink targets were not reused.  Note
 134 # that since the ciphertexts should be unpredictable, we cannot simply include
 135 # the expected names in the expected output file.
 136 _scratch_mount
 137 find $SCRATCH_MNT/encrypted_dir -type l | wc -l
 138 link1=$(find $SCRATCH_MNT/encrypted_dir -type l | head -1)
 139 link2=$(find $SCRATCH_MNT/encrypted_dir -type l | tail -1)
 140 [ $(basename $link1) = $(basename $link2) ] && \
 141         echo "Encrypted filenames were reused!"
 142 [ $(readlink $link1) = $(readlink $link2) ] && \
 143         echo "Encrypted symlink targets were reused!"
 144
 145 # success, all done
 146 status=0
 147 exit