xref: /qemu/tests/qemu-iotests/296 (revision a976a99a) 
1#!/usr/bin/env python3
2# group: rw
3#
4# Test case for encryption key management versus image sharing
5#
6# Copyright (C) 2019 Red Hat, Inc.
7#
8# This program is free software; you can redistribute it and/or modify
9# it under the terms of the GNU General Public License as published by
10# the Free Software Foundation; either version 2 of the License, or
11# (at your option) any later version.
12#
13# This program is distributed in the hope that it will be useful,
14# but WITHOUT ANY WARRANTY; without even the implied warranty of
15# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16# GNU General Public License for more details.
17#
18# You should have received a copy of the GNU General Public License
19# along with this program.  If not, see <http://www.gnu.org/licenses/>.
20#
21
22import iotests
23import os
24import time
25import json
26
27test_img = os.path.join(iotests.test_dir, 'test.img')
28
29class Secret:
30    def __init__(self, index):
31        self._id = "keysec" + str(index)
32        # you are not supposed to see the password...
33        self._secret = "hunter" + str(index)
34
35    def id(self):
36        return self._id
37
38    def secret(self):
39        return self._secret
40
41    def to_cmdline_object(self):
42        return  [ "secret,id=" + self._id + ",data=" + self._secret]
43
44    def to_qmp_object(self):
45        return { "qom_type" : "secret", "id": self.id(),
46                 "data": self.secret() }
47
48################################################################################
49
50class EncryptionSetupTestCase(iotests.QMPTestCase):
51
52    # test case startup
53    def setUp(self):
54
55        # start the VMs
56        self.vm1 = iotests.VM(path_suffix = 'VM1')
57        self.vm2 = iotests.VM(path_suffix = 'VM2')
58        self.vm1.launch()
59        self.vm2.launch()
60
61        # create the secrets and load 'em into the VMs
62        self.secrets = [ Secret(i) for i in range(0, 4) ]
63        for secret in self.secrets:
64            result = self.vm1.qmp("object-add", **secret.to_qmp_object())
65            self.assert_qmp(result, 'return', {})
66            result = self.vm2.qmp("object-add", **secret.to_qmp_object())
67            self.assert_qmp(result, 'return', {})
68
69    # test case shutdown
70    def tearDown(self):
71        # stop the VM
72        self.vm1.shutdown()
73        self.vm2.shutdown()
74
75    ###########################################################################
76    # create the encrypted block device using qemu-img
77    def createImg(self, file, secret):
78
79        iotests.qemu_img(
80            'create',
81            '--object', *secret.to_cmdline_object(),
82            '-f', iotests.imgfmt,
83            '-o', 'key-secret=' + secret.id(),
84            '-o', 'iter-time=10',
85            file,
86            '1M')
87        iotests.log('')
88
89    # attempts to add a key using qemu-img
90    def addKey(self, file, secret, new_secret):
91
92        image_options = {
93            'key-secret' : secret.id(),
94            'driver' : iotests.imgfmt,
95            'file' : {
96                'driver':'file',
97                'filename': file,
98                }
99            }
100
101        output = iotests.qemu_img(
102            'amend',
103            '--object', *secret.to_cmdline_object(),
104            '--object', *new_secret.to_cmdline_object(),
105
106            '-o', 'state=active',
107            '-o', 'new-secret=' + new_secret.id(),
108            '-o', 'iter-time=10',
109
110            "json:" + json.dumps(image_options),
111            check=False  # Expected to fail. Log output.
112        ).stdout
113
114        iotests.log(output, filters=[iotests.filter_test_dir])
115
116    ###########################################################################
117    # open an encrypted block device
118    def openImageQmp(self, vm, id, file, secret,
119                     readOnly = False, reOpen = False):
120
121        command = 'blockdev-reopen' if reOpen else 'blockdev-add'
122
123        opts = {
124                'driver': iotests.imgfmt,
125                'node-name': id,
126                'read-only': readOnly,
127                'key-secret' : secret.id(),
128                'file': {
129                    'driver': 'file',
130                    'filename': test_img,
131                }
132            }
133
134        if reOpen:
135            result = vm.qmp(command, options=[opts])
136        else:
137            result = vm.qmp(command, **opts)
138        self.assert_qmp(result, 'return', {})
139
140
141    ###########################################################################
142    # add virtio-blk consumer for a block device
143    def addImageUser(self, vm, id, disk_id, share_rw=False):
144        result = vm.qmp('device_add', **
145            {
146                'driver': 'virtio-blk',
147                'id': id,
148                'drive': disk_id,
149                'share-rw' : share_rw
150            }
151        )
152
153        iotests.log(result)
154
155    # close the encrypted block device
156    def closeImageQmp(self, vm, id):
157        result = vm.qmp('blockdev-del', **{ 'node-name': id })
158        self.assert_qmp(result, 'return', {})
159
160    ###########################################################################
161
162    # add a key to an encrypted block device
163    def addKeyQmp(self, vm, id, new_secret):
164
165        args = {
166            'node-name': id,
167            'job-id' : 'job0',
168            'options' : {
169                'state'     : 'active',
170                'driver'    : iotests.imgfmt,
171                'new-secret': new_secret.id(),
172                'iter-time' : 10
173            },
174        }
175
176        result = vm.qmp('x-blockdev-amend', **args)
177        iotests.log(result)
178        # Run the job only if it was created
179        event = ('JOB_STATUS_CHANGE',
180                 {'data': {'id': 'job0', 'status': 'created'}})
181        if vm.events_wait([event], timeout=0.0) is not None:
182            vm.run_job('job0')
183
184    # test that when the image opened by two qemu processes,
185    # neither of them can update the encryption keys
186    def test1(self):
187        self.createImg(test_img, self.secrets[0]);
188
189        # VM1 opens the image and adds a key
190        self.openImageQmp(self.vm1, "testdev", test_img, self.secrets[0])
191        self.addKeyQmp(self.vm1, "testdev", new_secret = self.secrets[1])
192
193
194        # VM2 opens the image
195        self.openImageQmp(self.vm2, "testdev", test_img, self.secrets[0])
196
197
198        # neither VMs now should be able to add a key
199        self.addKeyQmp(self.vm1, "testdev", new_secret = self.secrets[2])
200        self.addKeyQmp(self.vm2, "testdev", new_secret = self.secrets[2])
201
202
203        # VM 1 closes the image
204        self.closeImageQmp(self.vm1, "testdev")
205
206
207        # now VM2 can add the key
208        self.addKeyQmp(self.vm2, "testdev", new_secret = self.secrets[2])
209
210
211        # qemu-img should also not be able to add a key
212        self.addKey(test_img, self.secrets[0], self.secrets[2])
213
214        # cleanup
215        self.closeImageQmp(self.vm2, "testdev")
216        os.remove(test_img)
217
218
219    # test that when the image opened by two qemu processes,
220    # even if first VM opens it read-only, the second can't update encryption
221    # keys
222    def test2(self):
223        self.createImg(test_img, self.secrets[0]);
224
225        # VM1 opens the image readonly
226        self.openImageQmp(self.vm1, "testdev", test_img, self.secrets[0],
227                          readOnly = True)
228
229        # VM2 opens the image
230        self.openImageQmp(self.vm2, "testdev", test_img, self.secrets[0])
231
232        # VM1 can't add a key since image is readonly
233        self.addKeyQmp(self.vm1, "testdev", new_secret = self.secrets[2])
234
235        # VM2 can't add a key since VM is has the image opened
236        self.addKeyQmp(self.vm2, "testdev", new_secret = self.secrets[2])
237
238
239        #VM1 reopens the image read-write
240        self.openImageQmp(self.vm1, "testdev", test_img, self.secrets[0],
241                          reOpen = True, readOnly = False)
242
243        # VM1 still can't add the key
244        self.addKeyQmp(self.vm1, "testdev", new_secret = self.secrets[2])
245
246        # VM2 gets away
247        self.closeImageQmp(self.vm2, "testdev")
248
249        # VM1 now can add the key
250        self.addKeyQmp(self.vm1, "testdev", new_secret = self.secrets[2])
251
252        self.closeImageQmp(self.vm1, "testdev")
253        os.remove(test_img)
254
255    # test that two VMs can't open the same luks image by default
256    # and attach it to a guest device
257    def test3(self):
258        self.createImg(test_img, self.secrets[0]);
259
260        self.openImageQmp(self.vm1, "testdev", test_img, self.secrets[0])
261        self.addImageUser(self.vm1, "testctrl", "testdev")
262
263        self.openImageQmp(self.vm2, "testdev", test_img, self.secrets[0])
264        self.addImageUser(self.vm2, "testctrl", "testdev")
265
266
267    # test that two VMs can attach the same luks image to a guest device,
268    # if both use share-rw=on
269    def test4(self):
270        self.createImg(test_img, self.secrets[0]);
271
272        self.openImageQmp(self.vm1, "testdev", test_img, self.secrets[0])
273        self.addImageUser(self.vm1, "testctrl", "testdev", share_rw=True)
274
275        self.openImageQmp(self.vm2, "testdev", test_img, self.secrets[0])
276        self.addImageUser(self.vm2, "testctrl", "testdev", share_rw=True)
277
278
279
280if __name__ == '__main__':
281    # support only raw luks since luks encrypted qcow2 is a proper
282    # format driver which doesn't allow any sharing
283    iotests.activate_logging()
284    iotests.main(supported_fmts = ['luks'])
285