[mirror_qemu.git] / tests / qemu-iotests / 207

#!/usr/bin/env python3
# group: rw
#
# Test ssh image creation
#
# Copyright (C) 2018 Red Hat, Inc.
#
# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#

import iotests
import subprocess
import re

iotests.script_initialize(
    supported_fmts=['raw'],
    supported_protocols=['ssh'],
)

def filter_hash(qmsg):
    def _filter(key, value):
        if key == 'hash' and re.match('[0-9a-f]+', value):
            return 'HASH'
        return value
    if isinstance(qmsg, str):
        # Strip key type and fingerprint
        p = r"\S+ (key fingerprint) '(md5|sha1|sha256):[0-9a-f]+'"
        return re.sub(p, r"\1 '\2:HASH'", qmsg)
    else:
        return iotests.filter_qmp(qmsg, _filter)

def blockdev_create(vm, options):
    vm.blockdev_create(options, filters=[iotests.filter_qmp_testfiles, filter_hash])

with iotests.FilePath('t.img') as disk_path, \
     iotests.VM() as vm:

    remote_path = iotests.remote_filename(disk_path)

    #
    # Successful image creation (defaults)
    #
    iotests.log("=== Successful image creation (defaults) ===")
    iotests.log("")

    vm.launch()
    blockdev_create(vm, { 'driver': 'ssh',
                          'location': {
                              'path': disk_path,
                              'server': {
                                  'host': '127.0.0.1',
                                  'port': '22'
                              }
                          },
                          'size': 4194304 })
    vm.shutdown()

    iotests.img_info_log(remote_path)
    iotests.log("")
    iotests.img_info_log(disk_path)

    #
    # Test host-key-check options
    #
    iotests.log("=== Test host-key-check options ===")
    iotests.log("")

    iotests.log("--- no host key checking --")
    iotests.log("")

    vm.launch()
    blockdev_create(vm, { 'driver': 'ssh',
                          'location': {
                              'path': disk_path,
                              'server': {
                                  'host': '127.0.0.1',
                                  'port': '22'
                              },
                              'host-key-check': {
                                  'mode': 'none'
                              }
                          },
                          'size': 8388608 })
    vm.shutdown()

    iotests.img_info_log(remote_path)

    iotests.log("--- known_hosts key checking --")
    iotests.log("")

    vm.launch()
    blockdev_create(vm, { 'driver': 'ssh',
                          'location': {
                              'path': disk_path,
                              'server': {
                                  'host': '127.0.0.1',
                                  'port': '22'
                              },
                              'host-key-check': {
                                  'mode': 'known_hosts'
                              }
                          },
                          'size': 4194304 })
    vm.shutdown()

    iotests.img_info_log(remote_path)

    keys = subprocess.check_output(
        'ssh-keyscan 127.0.0.1 2>/dev/null | grep -v "\\^#" | ' +
        'cut -d" " -f3',
        shell=True).rstrip().decode('ascii').split('\n')

    # Mappings of base64 representations to digests
    md5_keys = {}
    sha1_keys = {}
    sha256_keys = {}

    for key in keys:
        md5_keys[key] = subprocess.check_output(
            'echo %s | base64 -d | md5sum -b | cut -d" " -f1' % key,
            shell=True).rstrip().decode('ascii')

        sha1_keys[key] = subprocess.check_output(
            'echo %s | base64 -d | sha1sum -b | cut -d" " -f1' % key,
            shell=True).rstrip().decode('ascii')

        sha256_keys[key] = subprocess.check_output(
            'echo %s | base64 -d | sha256sum -b | cut -d" " -f1' % key,
            shell=True).rstrip().decode('ascii')

    vm.launch()

    # Find correct key first
    matching_key = None
    for key in keys:
        result = vm.qmp('blockdev-add',
                        driver='ssh', node_name='node0', path=disk_path,
                        server={
                             'host': '127.0.0.1',
                             'port': '22',
                        }, host_key_check={
                             'mode': 'hash',
                             'type': 'md5',
                             'hash': md5_keys[key],
                        })

        if 'error' not in result:
            vm.qmp('blockdev-del', node_name='node0')
            matching_key = key
            break

    if matching_key is None:
        vm.shutdown()
        iotests.notrun('Did not find a key that fits 127.0.0.1')

    iotests.log("--- explicit md5 key checking --")
    iotests.log("")

    blockdev_create(vm, { 'driver': 'ssh',
                          'location': {
                              'path': disk_path,
                              'server': {
                                  'host': '127.0.0.1',
                                  'port': '22'
                              },
                              'host-key-check': {
                                  'mode': 'hash',
                                  'type': 'md5',
                                  'hash': 'wrong',
                              }
                          },
                          'size': 2097152 })

    blockdev_create(vm, { 'driver': 'ssh',
                          'location': {
                              'path': disk_path,
                              'server': {
                                  'host': '127.0.0.1',
                                  'port': '22'
                              },
                              'host-key-check': {
                                  'mode': 'hash',
                                  'type': 'md5',
                                  'hash': md5_keys[matching_key],
                              }
                          },
                          'size': 8388608 })
    vm.shutdown()

    iotests.img_info_log(remote_path)

    iotests.log("--- explicit sha1 key checking --")
    iotests.log("")

    vm.launch()
    blockdev_create(vm, { 'driver': 'ssh',
                          'location': {
                              'path': disk_path,
                              'server': {
                                  'host': '127.0.0.1',
                                  'port': '22'
                              },
                              'host-key-check': {
                                  'mode': 'hash',
                                  'type': 'sha1',
                                  'hash': 'wrong',
                              }
                          },
                          'size': 2097152 })
    blockdev_create(vm, { 'driver': 'ssh',
                          'location': {
                              'path': disk_path,
                              'server': {
                                  'host': '127.0.0.1',
                                  'port': '22'
                              },
                              'host-key-check': {
                                  'mode': 'hash',
                                  'type': 'sha1',
                                  'hash': sha1_keys[matching_key],
                              }
                          },
                          'size': 4194304 })
    vm.shutdown()

    iotests.img_info_log(remote_path)

    iotests.log("--- explicit sha256 key checking --")
    iotests.log("")

    vm.launch()
    blockdev_create(vm, { 'driver': 'ssh',
                          'location': {
                              'path': disk_path,
                              'server': {
                                  'host': '127.0.0.1',
                                  'port': '22'
                              },
                              'host-key-check': {
                                  'mode': 'hash',
                                  'type': 'sha256',
                                  'hash': 'wrong',
                              }
                          },
                          'size': 2097152 })
    blockdev_create(vm, { 'driver': 'ssh',
                          'location': {
                              'path': disk_path,
                              'server': {
                                  'host': '127.0.0.1',
                                  'port': '22'
                              },
                              'host-key-check': {
                                  'mode': 'hash',
                                  'type': 'sha256',
                                  'hash': sha256_keys[matching_key],
                              }
                          },
                          'size': 4194304 })
    vm.shutdown()

    iotests.img_info_log(remote_path)

    #
    # Invalid path and user
    #
    iotests.log("=== Invalid path and user ===")
    iotests.log("")

    vm.launch()
    blockdev_create(vm, { 'driver': 'ssh',
                          'location': {
                              'path': '/this/is/not/an/existing/path',
                              'server': {
                                  'host': '127.0.0.1',
                                  'port': '22'
                              },
                              'host-key-check': {
                                  'mode': 'none'
                              }
                          },
                          'size': 4194304 })
    blockdev_create(vm, { 'driver': 'ssh',
                          'location': {
                              'path': disk_path,
                              'user': 'invalid user',
                              'server': {
                                  'host': '127.0.0.1',
                                  'port': '22'
                              },
                              'host-key-check': {
                                  'mode': 'none'
                              }
                          },
                          'size': 4194304 })
    vm.shutdown()
Commit	Line	Data
7c477526	1	#!/usr/bin/env python3
9dd003a9	2	# group: rw
56ea7450 KW	3	#
	4	# Test ssh image creation
	5	#
	6	# Copyright (C) 2018 Red Hat, Inc.
	7	#
00af1935 KW	8	# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
00af1935 KW	9	#
56ea7450 KW	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
00af1935 KW	24	import iotests
	25	import subprocess
	26	import re
	27
7d814059 JS	28	iotests.script_initialize(
	29	supported_fmts=['raw'],
	30	supported_protocols=['ssh'],
	31	)
00af1935	32
9ac10f2e HR	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
48f1fcd5 HR	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)
00af1935 KW	44
00af1935 KW	45	def blockdev_create(vm, options):
6055cdf3	46	vm.blockdev_create(options, filters=[iotests.filter_qmp_testfiles, filter_hash])
00af1935 KW	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
b8c1f901	71	iotests.img_info_log(remote_path)
00af1935 KW	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
bf783261 DB	81	iotests.log("--- no host key checking --")
	82	iotests.log("")
	83
00af1935 KW	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
b8c1f901	99	iotests.img_info_log(remote_path)
00af1935	100
bf783261 DB	101	iotests.log("--- known_hosts key checking --")
	102	iotests.log("")
	103
00af1935 KW	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
b8c1f901	119	iotests.img_info_log(remote_path)
00af1935	120
b10d49d7 PT	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 = {}
bf783261	129	sha256_keys = {}
b10d49d7 PT	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')
00af1935	139
bf783261 DB	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
00af1935	144	vm.launch()
b10d49d7 PT	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
bf783261 DB	169	iotests.log("--- explicit md5 key checking --")
	170	iotests.log("")
	171
00af1935 KW	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 })
bf783261	186
00af1935 KW	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',
b10d49d7	197	'hash': md5_keys[matching_key],
00af1935 KW	198	}
	199	},
	200	'size': 8388608 })
	201	vm.shutdown()
	202
b8c1f901	203	iotests.img_info_log(remote_path)
00af1935	204
bf783261 DB	205	iotests.log("--- explicit sha1 key checking --")
	206	iotests.log("")
	207
00af1935 KW	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',
b10d49d7	233	'hash': sha1_keys[matching_key],
00af1935 KW	234	}
	235	},
	236	'size': 4194304 })
	237	vm.shutdown()
	238
b8c1f901	239	iotests.img_info_log(remote_path)
00af1935	240
bf783261 DB	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
00af1935 KW	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()