tests/qemu-iotests/207

   1 #!/usr/bin/env python3
   2 # group: rw
   3 #
   4 # Test ssh image creation
   5 #
   6 # Copyright (C) 2018 Red Hat, Inc.
   7 #
   8 # Creator/Owner: Kevin Wolf <kwolf@redhat.com>
   9 #
  10 # This program is free software; you can redistribute it and/or modify
  11 # it under the terms of the GNU General Public License as published by
  12 # the Free Software Foundation; either version 2 of the License, or
  13 # (at your option) any later version.
  14 #
  15 # This program is distributed in the hope that it will be useful,
  16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 # GNU General Public License for more details.
  19 #
  20 # You should have received a copy of the GNU General Public License
  21 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 #
  23
  24 import iotests
  25 import subprocess
  26 import re
  27
  28 iotests.script_initialize(
  29     supported_fmts=['raw'],
  30     supported_protocols=['ssh'],
  31 )
  32
  33 def filter_hash(qmsg):
  34     def _filter(key, value):
  35         if key == 'hash' and re.match('[0-9a-f]+', value):
  36             return 'HASH'
  37         return value
  38     if isinstance(qmsg, str):
  39         # Strip key type and fingerprint
  40         p = r"\S+ (key fingerprint) '(md5|sha1|sha256):[0-9a-f]+'"
  41         return re.sub(p, r"\1 '\2:HASH'", qmsg)
  42     else:
  43         return iotests.filter_qmp(qmsg, _filter)
  44
  45 def blockdev_create(vm, options):
  46     vm.blockdev_create(options, filters=[iotests.filter_qmp_testfiles, filter_hash])
  47
  48 with iotests.FilePath('t.img') as disk_path, \
  49      iotests.VM() as vm:
  50
  51     remote_path = iotests.remote_filename(disk_path)
  52
  53     #
  54     # Successful image creation (defaults)
  55     #
  56     iotests.log("=== Successful image creation (defaults) ===")
  57     iotests.log("")
  58
  59     vm.launch()
  60     blockdev_create(vm, { 'driver': 'ssh',
  61                           'location': {
  62                               'path': disk_path,
  63                               'server': {
  64                                   'host': '127.0.0.1',
  65                                   'port': '22'
  66                               }
  67                           },
  68                           'size': 4194304 })
  69     vm.shutdown()
  70
  71     iotests.img_info_log(remote_path)
  72     iotests.log("")
  73     iotests.img_info_log(disk_path)
  74
  75     #
  76     # Test host-key-check options
  77     #
  78     iotests.log("=== Test host-key-check options ===")
  79     iotests.log("")
  80
  81     iotests.log("--- no host key checking --")
  82     iotests.log("")
  83
  84     vm.launch()
  85     blockdev_create(vm, { 'driver': 'ssh',
  86                           'location': {
  87                               'path': disk_path,
  88                               'server': {
  89                                   'host': '127.0.0.1',
  90                                   'port': '22'
  91                               },
  92                               'host-key-check': {
  93                                   'mode': 'none'
  94                               }
  95                           },
  96                           'size': 8388608 })
  97     vm.shutdown()
  98
  99     iotests.img_info_log(remote_path)
 100
 101     iotests.log("--- known_hosts key checking --")
 102     iotests.log("")
 103
 104     vm.launch()
 105     blockdev_create(vm, { 'driver': 'ssh',
 106                           'location': {
 107                               'path': disk_path,
 108                               'server': {
 109                                   'host': '127.0.0.1',
 110                                   'port': '22'
 111                               },
 112                               'host-key-check': {
 113                                   'mode': 'known_hosts'
 114                               }
 115                           },
 116                           'size': 4194304 })
 117     vm.shutdown()
 118
 119     iotests.img_info_log(remote_path)
 120
 121     keys = subprocess.check_output(
 122         'ssh-keyscan 127.0.0.1 2>/dev/null | grep -v "\\^#" | ' +
 123         'cut -d" " -f3',
 124         shell=True).rstrip().decode('ascii').split('\n')
 125
 126     # Mappings of base64 representations to digests
 127     md5_keys = {}
 128     sha1_keys = {}
 129     sha256_keys = {}
 130
 131     for key in keys:
 132         md5_keys[key] = subprocess.check_output(
 133             'echo %s | base64 -d | md5sum -b | cut -d" " -f1' % key,
 134             shell=True).rstrip().decode('ascii')
 135
 136         sha1_keys[key] = subprocess.check_output(
 137             'echo %s | base64 -d | sha1sum -b | cut -d" " -f1' % key,
 138             shell=True).rstrip().decode('ascii')
 139
 140         sha256_keys[key] = subprocess.check_output(
 141             'echo %s | base64 -d | sha256sum -b | cut -d" " -f1' % key,
 142             shell=True).rstrip().decode('ascii')
 143
 144     vm.launch()
 145
 146     # Find correct key first
 147     matching_key = None
 148     for key in keys:
 149         result = vm.qmp('blockdev-add',
 150                         driver='ssh', node_name='node0', path=disk_path,
 151                         server={
 152                              'host': '127.0.0.1',
 153                              'port': '22',
 154                         }, host_key_check={
 155                              'mode': 'hash',
 156                              'type': 'md5',
 157                              'hash': md5_keys[key],
 158                         })
 159
 160         if 'error' not in result:
 161             vm.qmp('blockdev-del', node_name='node0')
 162             matching_key = key
 163             break
 164
 165     if matching_key is None:
 166         vm.shutdown()
 167         iotests.notrun('Did not find a key that fits 127.0.0.1')
 168
 169     iotests.log("--- explicit md5 key checking --")
 170     iotests.log("")
 171
 172     blockdev_create(vm, { 'driver': 'ssh',
 173                           'location': {
 174                               'path': disk_path,
 175                               'server': {
 176                                   'host': '127.0.0.1',
 177                                   'port': '22'
 178                               },
 179                               'host-key-check': {
 180                                   'mode': 'hash',
 181                                   'type': 'md5',
 182                                   'hash': 'wrong',
 183                               }
 184                           },
 185                           'size': 2097152 })
 186
 187     blockdev_create(vm, { 'driver': 'ssh',
 188                           'location': {
 189                               'path': disk_path,
 190                               'server': {
 191                                   'host': '127.0.0.1',
 192                                   'port': '22'
 193                               },
 194                               'host-key-check': {
 195                                   'mode': 'hash',
 196                                   'type': 'md5',
 197                                   'hash': md5_keys[matching_key],
 198                               }
 199                           },
 200                           'size': 8388608 })
 201     vm.shutdown()
 202
 203     iotests.img_info_log(remote_path)
 204
 205     iotests.log("--- explicit sha1 key checking --")
 206     iotests.log("")
 207
 208     vm.launch()
 209     blockdev_create(vm, { 'driver': 'ssh',
 210                           'location': {
 211                               'path': disk_path,
 212                               'server': {
 213                                   'host': '127.0.0.1',
 214                                   'port': '22'
 215                               },
 216                               'host-key-check': {
 217                                   'mode': 'hash',
 218                                   'type': 'sha1',
 219                                   'hash': 'wrong',
 220                               }
 221                           },
 222                           'size': 2097152 })
 223     blockdev_create(vm, { 'driver': 'ssh',
 224                           'location': {
 225                               'path': disk_path,
 226                               'server': {
 227                                   'host': '127.0.0.1',
 228                                   'port': '22'
 229                               },
 230                               'host-key-check': {
 231                                   'mode': 'hash',
 232                                   'type': 'sha1',
 233                                   'hash': sha1_keys[matching_key],
 234                               }
 235                           },
 236                           'size': 4194304 })
 237     vm.shutdown()
 238
 239     iotests.img_info_log(remote_path)
 240
 241     iotests.log("--- explicit sha256 key checking --")
 242     iotests.log("")
 243
 244     vm.launch()
 245     blockdev_create(vm, { 'driver': 'ssh',
 246                           'location': {
 247                               'path': disk_path,
 248                               'server': {
 249                                   'host': '127.0.0.1',
 250                                   'port': '22'
 251                               },
 252                               'host-key-check': {
 253                                   'mode': 'hash',
 254                                   'type': 'sha256',
 255                                   'hash': 'wrong',
 256                               }
 257                           },
 258                           'size': 2097152 })
 259     blockdev_create(vm, { 'driver': 'ssh',
 260                           'location': {
 261                               'path': disk_path,
 262                               'server': {
 263                                   'host': '127.0.0.1',
 264                                   'port': '22'
 265                               },
 266                               'host-key-check': {
 267                                   'mode': 'hash',
 268                                   'type': 'sha256',
 269                                   'hash': sha256_keys[matching_key],
 270                               }
 271                           },
 272                           'size': 4194304 })
 273     vm.shutdown()
 274
 275     iotests.img_info_log(remote_path)
 276
 277     #
 278     # Invalid path and user
 279     #
 280     iotests.log("=== Invalid path and user ===")
 281     iotests.log("")
 282
 283     vm.launch()
 284     blockdev_create(vm, { 'driver': 'ssh',
 285                           'location': {
 286                               'path': '/this/is/not/an/existing/path',
 287                               'server': {
 288                                   'host': '127.0.0.1',
 289                                   'port': '22'
 290                               },
 291                               'host-key-check': {
 292                                   'mode': 'none'
 293                               }
 294                           },
 295                           'size': 4194304 })
 296     blockdev_create(vm, { 'driver': 'ssh',
 297                           'location': {
 298                               'path': disk_path,
 299                               'user': 'invalid user',
 300                               'server': {
 301                                   'host': '127.0.0.1',
 302                                   'port': '22'
 303                               },
 304                               'host-key-check': {
 305                                   'mode': 'none'
 306                               }
 307                           },
 308                           'size': 4194304 })
 309     vm.shutdown()