For one thing, this allows us to drop the error message generation from qemu-img.c and blockdev.c and instead have it unified in bdrv_truncate(). Signed-off-by: Max Reitz <mreitz@redhat.com> Message-id: 20170328205129.15138-3-mreitz@redhat.com Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com> Signed-off-by: Max Reitz <mreitz@redhat.com>
649 lines
18 KiB
C
649 lines
18 KiB
C
/*
|
|
* QEMU block full disk encryption
|
|
*
|
|
* Copyright (c) 2015-2016 Red Hat, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
|
|
#include "block/block_int.h"
|
|
#include "sysemu/block-backend.h"
|
|
#include "crypto/block.h"
|
|
#include "qapi/opts-visitor.h"
|
|
#include "qapi-visit.h"
|
|
#include "qapi/error.h"
|
|
|
|
#define BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET "key-secret"
|
|
#define BLOCK_CRYPTO_OPT_LUKS_CIPHER_ALG "cipher-alg"
|
|
#define BLOCK_CRYPTO_OPT_LUKS_CIPHER_MODE "cipher-mode"
|
|
#define BLOCK_CRYPTO_OPT_LUKS_IVGEN_ALG "ivgen-alg"
|
|
#define BLOCK_CRYPTO_OPT_LUKS_IVGEN_HASH_ALG "ivgen-hash-alg"
|
|
#define BLOCK_CRYPTO_OPT_LUKS_HASH_ALG "hash-alg"
|
|
#define BLOCK_CRYPTO_OPT_LUKS_ITER_TIME "iter-time"
|
|
|
|
typedef struct BlockCrypto BlockCrypto;
|
|
|
|
struct BlockCrypto {
|
|
QCryptoBlock *block;
|
|
};
|
|
|
|
|
|
static int block_crypto_probe_generic(QCryptoBlockFormat format,
|
|
const uint8_t *buf,
|
|
int buf_size,
|
|
const char *filename)
|
|
{
|
|
if (qcrypto_block_has_format(format, buf, buf_size)) {
|
|
return 100;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
static ssize_t block_crypto_read_func(QCryptoBlock *block,
|
|
void *opaque,
|
|
size_t offset,
|
|
uint8_t *buf,
|
|
size_t buflen,
|
|
Error **errp)
|
|
{
|
|
BlockDriverState *bs = opaque;
|
|
ssize_t ret;
|
|
|
|
ret = bdrv_pread(bs->file, offset, buf, buflen);
|
|
if (ret < 0) {
|
|
error_setg_errno(errp, -ret, "Could not read encryption header");
|
|
return ret;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
struct BlockCryptoCreateData {
|
|
const char *filename;
|
|
QemuOpts *opts;
|
|
BlockBackend *blk;
|
|
uint64_t size;
|
|
};
|
|
|
|
|
|
static ssize_t block_crypto_write_func(QCryptoBlock *block,
|
|
void *opaque,
|
|
size_t offset,
|
|
const uint8_t *buf,
|
|
size_t buflen,
|
|
Error **errp)
|
|
{
|
|
struct BlockCryptoCreateData *data = opaque;
|
|
ssize_t ret;
|
|
|
|
ret = blk_pwrite(data->blk, offset, buf, buflen, 0);
|
|
if (ret < 0) {
|
|
error_setg_errno(errp, -ret, "Could not write encryption header");
|
|
return ret;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
static ssize_t block_crypto_init_func(QCryptoBlock *block,
|
|
void *opaque,
|
|
size_t headerlen,
|
|
Error **errp)
|
|
{
|
|
struct BlockCryptoCreateData *data = opaque;
|
|
int ret;
|
|
|
|
/* User provided size should reflect amount of space made
|
|
* available to the guest, so we must take account of that
|
|
* which will be used by the crypto header
|
|
*/
|
|
data->size += headerlen;
|
|
|
|
qemu_opt_set_number(data->opts, BLOCK_OPT_SIZE, data->size, &error_abort);
|
|
ret = bdrv_create_file(data->filename, data->opts, errp);
|
|
if (ret < 0) {
|
|
return -1;
|
|
}
|
|
|
|
data->blk = blk_new_open(data->filename, NULL, NULL,
|
|
BDRV_O_RDWR | BDRV_O_PROTOCOL, errp);
|
|
if (!data->blk) {
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static QemuOptsList block_crypto_runtime_opts_luks = {
|
|
.name = "crypto",
|
|
.head = QTAILQ_HEAD_INITIALIZER(block_crypto_runtime_opts_luks.head),
|
|
.desc = {
|
|
{
|
|
.name = BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET,
|
|
.type = QEMU_OPT_STRING,
|
|
.help = "ID of the secret that provides the encryption key",
|
|
},
|
|
{ /* end of list */ }
|
|
},
|
|
};
|
|
|
|
|
|
static QemuOptsList block_crypto_create_opts_luks = {
|
|
.name = "crypto",
|
|
.head = QTAILQ_HEAD_INITIALIZER(block_crypto_create_opts_luks.head),
|
|
.desc = {
|
|
{
|
|
.name = BLOCK_OPT_SIZE,
|
|
.type = QEMU_OPT_SIZE,
|
|
.help = "Virtual disk size"
|
|
},
|
|
{
|
|
.name = BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET,
|
|
.type = QEMU_OPT_STRING,
|
|
.help = "ID of the secret that provides the encryption key",
|
|
},
|
|
{
|
|
.name = BLOCK_CRYPTO_OPT_LUKS_CIPHER_ALG,
|
|
.type = QEMU_OPT_STRING,
|
|
.help = "Name of encryption cipher algorithm",
|
|
},
|
|
{
|
|
.name = BLOCK_CRYPTO_OPT_LUKS_CIPHER_MODE,
|
|
.type = QEMU_OPT_STRING,
|
|
.help = "Name of encryption cipher mode",
|
|
},
|
|
{
|
|
.name = BLOCK_CRYPTO_OPT_LUKS_IVGEN_ALG,
|
|
.type = QEMU_OPT_STRING,
|
|
.help = "Name of IV generator algorithm",
|
|
},
|
|
{
|
|
.name = BLOCK_CRYPTO_OPT_LUKS_IVGEN_HASH_ALG,
|
|
.type = QEMU_OPT_STRING,
|
|
.help = "Name of IV generator hash algorithm",
|
|
},
|
|
{
|
|
.name = BLOCK_CRYPTO_OPT_LUKS_HASH_ALG,
|
|
.type = QEMU_OPT_STRING,
|
|
.help = "Name of encryption hash algorithm",
|
|
},
|
|
{
|
|
.name = BLOCK_CRYPTO_OPT_LUKS_ITER_TIME,
|
|
.type = QEMU_OPT_NUMBER,
|
|
.help = "Time to spend in PBKDF in milliseconds",
|
|
},
|
|
{ /* end of list */ }
|
|
},
|
|
};
|
|
|
|
|
|
static QCryptoBlockOpenOptions *
|
|
block_crypto_open_opts_init(QCryptoBlockFormat format,
|
|
QemuOpts *opts,
|
|
Error **errp)
|
|
{
|
|
Visitor *v;
|
|
QCryptoBlockOpenOptions *ret = NULL;
|
|
Error *local_err = NULL;
|
|
|
|
ret = g_new0(QCryptoBlockOpenOptions, 1);
|
|
ret->format = format;
|
|
|
|
v = opts_visitor_new(opts);
|
|
|
|
visit_start_struct(v, NULL, NULL, 0, &local_err);
|
|
if (local_err) {
|
|
goto out;
|
|
}
|
|
|
|
switch (format) {
|
|
case Q_CRYPTO_BLOCK_FORMAT_LUKS:
|
|
visit_type_QCryptoBlockOptionsLUKS_members(
|
|
v, &ret->u.luks, &local_err);
|
|
break;
|
|
|
|
default:
|
|
error_setg(&local_err, "Unsupported block format %d", format);
|
|
break;
|
|
}
|
|
if (!local_err) {
|
|
visit_check_struct(v, &local_err);
|
|
}
|
|
|
|
visit_end_struct(v, NULL);
|
|
|
|
out:
|
|
if (local_err) {
|
|
error_propagate(errp, local_err);
|
|
qapi_free_QCryptoBlockOpenOptions(ret);
|
|
ret = NULL;
|
|
}
|
|
visit_free(v);
|
|
return ret;
|
|
}
|
|
|
|
|
|
static QCryptoBlockCreateOptions *
|
|
block_crypto_create_opts_init(QCryptoBlockFormat format,
|
|
QemuOpts *opts,
|
|
Error **errp)
|
|
{
|
|
Visitor *v;
|
|
QCryptoBlockCreateOptions *ret = NULL;
|
|
Error *local_err = NULL;
|
|
|
|
ret = g_new0(QCryptoBlockCreateOptions, 1);
|
|
ret->format = format;
|
|
|
|
v = opts_visitor_new(opts);
|
|
|
|
visit_start_struct(v, NULL, NULL, 0, &local_err);
|
|
if (local_err) {
|
|
goto out;
|
|
}
|
|
|
|
switch (format) {
|
|
case Q_CRYPTO_BLOCK_FORMAT_LUKS:
|
|
visit_type_QCryptoBlockCreateOptionsLUKS_members(
|
|
v, &ret->u.luks, &local_err);
|
|
break;
|
|
|
|
default:
|
|
error_setg(&local_err, "Unsupported block format %d", format);
|
|
break;
|
|
}
|
|
if (!local_err) {
|
|
visit_check_struct(v, &local_err);
|
|
}
|
|
|
|
visit_end_struct(v, NULL);
|
|
|
|
out:
|
|
if (local_err) {
|
|
error_propagate(errp, local_err);
|
|
qapi_free_QCryptoBlockCreateOptions(ret);
|
|
ret = NULL;
|
|
}
|
|
visit_free(v);
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int block_crypto_open_generic(QCryptoBlockFormat format,
|
|
QemuOptsList *opts_spec,
|
|
BlockDriverState *bs,
|
|
QDict *options,
|
|
int flags,
|
|
Error **errp)
|
|
{
|
|
BlockCrypto *crypto = bs->opaque;
|
|
QemuOpts *opts = NULL;
|
|
Error *local_err = NULL;
|
|
int ret = -EINVAL;
|
|
QCryptoBlockOpenOptions *open_opts = NULL;
|
|
unsigned int cflags = 0;
|
|
|
|
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
|
|
false, errp);
|
|
if (!bs->file) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
opts = qemu_opts_create(opts_spec, NULL, 0, &error_abort);
|
|
qemu_opts_absorb_qdict(opts, options, &local_err);
|
|
if (local_err) {
|
|
error_propagate(errp, local_err);
|
|
goto cleanup;
|
|
}
|
|
|
|
open_opts = block_crypto_open_opts_init(format, opts, errp);
|
|
if (!open_opts) {
|
|
goto cleanup;
|
|
}
|
|
|
|
if (flags & BDRV_O_NO_IO) {
|
|
cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;
|
|
}
|
|
crypto->block = qcrypto_block_open(open_opts,
|
|
block_crypto_read_func,
|
|
bs,
|
|
cflags,
|
|
errp);
|
|
|
|
if (!crypto->block) {
|
|
ret = -EIO;
|
|
goto cleanup;
|
|
}
|
|
|
|
bs->encrypted = true;
|
|
bs->valid_key = true;
|
|
|
|
ret = 0;
|
|
cleanup:
|
|
qapi_free_QCryptoBlockOpenOptions(open_opts);
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int block_crypto_create_generic(QCryptoBlockFormat format,
|
|
const char *filename,
|
|
QemuOpts *opts,
|
|
Error **errp)
|
|
{
|
|
int ret = -EINVAL;
|
|
QCryptoBlockCreateOptions *create_opts = NULL;
|
|
QCryptoBlock *crypto = NULL;
|
|
struct BlockCryptoCreateData data = {
|
|
.size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
|
|
BDRV_SECTOR_SIZE),
|
|
.opts = opts,
|
|
.filename = filename,
|
|
};
|
|
|
|
create_opts = block_crypto_create_opts_init(format, opts, errp);
|
|
if (!create_opts) {
|
|
return -1;
|
|
}
|
|
|
|
crypto = qcrypto_block_create(create_opts,
|
|
block_crypto_init_func,
|
|
block_crypto_write_func,
|
|
&data,
|
|
errp);
|
|
|
|
if (!crypto) {
|
|
ret = -EIO;
|
|
goto cleanup;
|
|
}
|
|
|
|
ret = 0;
|
|
cleanup:
|
|
qcrypto_block_free(crypto);
|
|
blk_unref(data.blk);
|
|
qapi_free_QCryptoBlockCreateOptions(create_opts);
|
|
return ret;
|
|
}
|
|
|
|
static int block_crypto_truncate(BlockDriverState *bs, int64_t offset)
|
|
{
|
|
BlockCrypto *crypto = bs->opaque;
|
|
size_t payload_offset =
|
|
qcrypto_block_get_payload_offset(crypto->block);
|
|
|
|
offset += payload_offset;
|
|
|
|
return bdrv_truncate(bs->file, offset, NULL);
|
|
}
|
|
|
|
static void block_crypto_close(BlockDriverState *bs)
|
|
{
|
|
BlockCrypto *crypto = bs->opaque;
|
|
qcrypto_block_free(crypto->block);
|
|
}
|
|
|
|
|
|
#define BLOCK_CRYPTO_MAX_SECTORS 32
|
|
|
|
static coroutine_fn int
|
|
block_crypto_co_readv(BlockDriverState *bs, int64_t sector_num,
|
|
int remaining_sectors, QEMUIOVector *qiov)
|
|
{
|
|
BlockCrypto *crypto = bs->opaque;
|
|
int cur_nr_sectors; /* number of sectors in current iteration */
|
|
uint64_t bytes_done = 0;
|
|
uint8_t *cipher_data = NULL;
|
|
QEMUIOVector hd_qiov;
|
|
int ret = 0;
|
|
size_t payload_offset =
|
|
qcrypto_block_get_payload_offset(crypto->block) / 512;
|
|
|
|
qemu_iovec_init(&hd_qiov, qiov->niov);
|
|
|
|
/* Bounce buffer so we have a linear mem region for
|
|
* entire sector. XXX optimize so we avoid bounce
|
|
* buffer in case that qiov->niov == 1
|
|
*/
|
|
cipher_data =
|
|
qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_SECTORS * 512,
|
|
qiov->size));
|
|
if (cipher_data == NULL) {
|
|
ret = -ENOMEM;
|
|
goto cleanup;
|
|
}
|
|
|
|
while (remaining_sectors) {
|
|
cur_nr_sectors = remaining_sectors;
|
|
|
|
if (cur_nr_sectors > BLOCK_CRYPTO_MAX_SECTORS) {
|
|
cur_nr_sectors = BLOCK_CRYPTO_MAX_SECTORS;
|
|
}
|
|
|
|
qemu_iovec_reset(&hd_qiov);
|
|
qemu_iovec_add(&hd_qiov, cipher_data, cur_nr_sectors * 512);
|
|
|
|
ret = bdrv_co_readv(bs->file,
|
|
payload_offset + sector_num,
|
|
cur_nr_sectors, &hd_qiov);
|
|
if (ret < 0) {
|
|
goto cleanup;
|
|
}
|
|
|
|
if (qcrypto_block_decrypt(crypto->block,
|
|
sector_num,
|
|
cipher_data, cur_nr_sectors * 512,
|
|
NULL) < 0) {
|
|
ret = -EIO;
|
|
goto cleanup;
|
|
}
|
|
|
|
qemu_iovec_from_buf(qiov, bytes_done,
|
|
cipher_data, cur_nr_sectors * 512);
|
|
|
|
remaining_sectors -= cur_nr_sectors;
|
|
sector_num += cur_nr_sectors;
|
|
bytes_done += cur_nr_sectors * 512;
|
|
}
|
|
|
|
cleanup:
|
|
qemu_iovec_destroy(&hd_qiov);
|
|
qemu_vfree(cipher_data);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static coroutine_fn int
|
|
block_crypto_co_writev(BlockDriverState *bs, int64_t sector_num,
|
|
int remaining_sectors, QEMUIOVector *qiov)
|
|
{
|
|
BlockCrypto *crypto = bs->opaque;
|
|
int cur_nr_sectors; /* number of sectors in current iteration */
|
|
uint64_t bytes_done = 0;
|
|
uint8_t *cipher_data = NULL;
|
|
QEMUIOVector hd_qiov;
|
|
int ret = 0;
|
|
size_t payload_offset =
|
|
qcrypto_block_get_payload_offset(crypto->block) / 512;
|
|
|
|
qemu_iovec_init(&hd_qiov, qiov->niov);
|
|
|
|
/* Bounce buffer so we have a linear mem region for
|
|
* entire sector. XXX optimize so we avoid bounce
|
|
* buffer in case that qiov->niov == 1
|
|
*/
|
|
cipher_data =
|
|
qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_SECTORS * 512,
|
|
qiov->size));
|
|
if (cipher_data == NULL) {
|
|
ret = -ENOMEM;
|
|
goto cleanup;
|
|
}
|
|
|
|
while (remaining_sectors) {
|
|
cur_nr_sectors = remaining_sectors;
|
|
|
|
if (cur_nr_sectors > BLOCK_CRYPTO_MAX_SECTORS) {
|
|
cur_nr_sectors = BLOCK_CRYPTO_MAX_SECTORS;
|
|
}
|
|
|
|
qemu_iovec_to_buf(qiov, bytes_done,
|
|
cipher_data, cur_nr_sectors * 512);
|
|
|
|
if (qcrypto_block_encrypt(crypto->block,
|
|
sector_num,
|
|
cipher_data, cur_nr_sectors * 512,
|
|
NULL) < 0) {
|
|
ret = -EIO;
|
|
goto cleanup;
|
|
}
|
|
|
|
qemu_iovec_reset(&hd_qiov);
|
|
qemu_iovec_add(&hd_qiov, cipher_data, cur_nr_sectors * 512);
|
|
|
|
ret = bdrv_co_writev(bs->file,
|
|
payload_offset + sector_num,
|
|
cur_nr_sectors, &hd_qiov);
|
|
if (ret < 0) {
|
|
goto cleanup;
|
|
}
|
|
|
|
remaining_sectors -= cur_nr_sectors;
|
|
sector_num += cur_nr_sectors;
|
|
bytes_done += cur_nr_sectors * 512;
|
|
}
|
|
|
|
cleanup:
|
|
qemu_iovec_destroy(&hd_qiov);
|
|
qemu_vfree(cipher_data);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int64_t block_crypto_getlength(BlockDriverState *bs)
|
|
{
|
|
BlockCrypto *crypto = bs->opaque;
|
|
int64_t len = bdrv_getlength(bs->file->bs);
|
|
|
|
ssize_t offset = qcrypto_block_get_payload_offset(crypto->block);
|
|
|
|
len -= offset;
|
|
|
|
return len;
|
|
}
|
|
|
|
|
|
static int block_crypto_probe_luks(const uint8_t *buf,
|
|
int buf_size,
|
|
const char *filename) {
|
|
return block_crypto_probe_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
|
|
buf, buf_size, filename);
|
|
}
|
|
|
|
static int block_crypto_open_luks(BlockDriverState *bs,
|
|
QDict *options,
|
|
int flags,
|
|
Error **errp)
|
|
{
|
|
return block_crypto_open_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
|
|
&block_crypto_runtime_opts_luks,
|
|
bs, options, flags, errp);
|
|
}
|
|
|
|
static int block_crypto_create_luks(const char *filename,
|
|
QemuOpts *opts,
|
|
Error **errp)
|
|
{
|
|
return block_crypto_create_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
|
|
filename, opts, errp);
|
|
}
|
|
|
|
static int block_crypto_get_info_luks(BlockDriverState *bs,
|
|
BlockDriverInfo *bdi)
|
|
{
|
|
BlockDriverInfo subbdi;
|
|
int ret;
|
|
|
|
ret = bdrv_get_info(bs->file->bs, &subbdi);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
|
|
bdi->unallocated_blocks_are_zero = false;
|
|
bdi->can_write_zeroes_with_unmap = false;
|
|
bdi->cluster_size = subbdi.cluster_size;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ImageInfoSpecific *
|
|
block_crypto_get_specific_info_luks(BlockDriverState *bs)
|
|
{
|
|
BlockCrypto *crypto = bs->opaque;
|
|
ImageInfoSpecific *spec_info;
|
|
QCryptoBlockInfo *info;
|
|
|
|
info = qcrypto_block_get_info(crypto->block, NULL);
|
|
if (!info) {
|
|
return NULL;
|
|
}
|
|
if (info->format != Q_CRYPTO_BLOCK_FORMAT_LUKS) {
|
|
qapi_free_QCryptoBlockInfo(info);
|
|
return NULL;
|
|
}
|
|
|
|
spec_info = g_new(ImageInfoSpecific, 1);
|
|
spec_info->type = IMAGE_INFO_SPECIFIC_KIND_LUKS;
|
|
spec_info->u.luks.data = g_new(QCryptoBlockInfoLUKS, 1);
|
|
*spec_info->u.luks.data = info->u.luks;
|
|
|
|
/* Blank out pointers we've just stolen to avoid double free */
|
|
memset(&info->u.luks, 0, sizeof(info->u.luks));
|
|
|
|
qapi_free_QCryptoBlockInfo(info);
|
|
|
|
return spec_info;
|
|
}
|
|
|
|
BlockDriver bdrv_crypto_luks = {
|
|
.format_name = "luks",
|
|
.instance_size = sizeof(BlockCrypto),
|
|
.bdrv_probe = block_crypto_probe_luks,
|
|
.bdrv_open = block_crypto_open_luks,
|
|
.bdrv_close = block_crypto_close,
|
|
.bdrv_child_perm = bdrv_format_default_perms,
|
|
.bdrv_create = block_crypto_create_luks,
|
|
.bdrv_truncate = block_crypto_truncate,
|
|
.create_opts = &block_crypto_create_opts_luks,
|
|
|
|
.bdrv_co_readv = block_crypto_co_readv,
|
|
.bdrv_co_writev = block_crypto_co_writev,
|
|
.bdrv_getlength = block_crypto_getlength,
|
|
.bdrv_get_info = block_crypto_get_info_luks,
|
|
.bdrv_get_specific_info = block_crypto_get_specific_info_luks,
|
|
};
|
|
|
|
static void block_crypto_init(void)
|
|
{
|
|
bdrv_register(&bdrv_crypto_luks);
|
|
}
|
|
|
|
block_init(block_crypto_init);
|