17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
51d8ed0f0Svikram * Common Development and Distribution License (the "License").
61d8ed0f0Svikram * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate *
87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate * and limitations under the License.
127c478bd9Sstevel@tonic-gate *
137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate *
197c478bd9Sstevel@tonic-gate * CDDL HEADER END
207c478bd9Sstevel@tonic-gate */
217c478bd9Sstevel@tonic-gate /*
22b1efbcd6SAlok Aggarwal * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
231d8ed0f0Svikram * Use is subject to license terms.
24789dced6SJerry Jelinek * Copyright 2012 Joyent, Inc. All rights reserved.
25cd69fabeSAlexander Eremin *
26cd69fabeSAlexander Eremin * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
276e096e64SGary Mills * Copyright (c) 2014 Gary Mills
284549a1bdSAndrey Sokolov * Copyright (c) 2016 Andrey Sokolov
293d7072f8Seschrock */
303d7072f8Seschrock
313d7072f8Seschrock /*
32*bbf21555SRichard Lowe * lofiadm - administer lofi(4D). Very simple, add and remove file<->device
337c478bd9Sstevel@tonic-gate * associations, and display status. All the ioctls are private between
347c478bd9Sstevel@tonic-gate * lofi and lofiadm, and so are very simple - device information is
357c478bd9Sstevel@tonic-gate * communicated via a minor number.
367c478bd9Sstevel@tonic-gate */
377c478bd9Sstevel@tonic-gate
387c478bd9Sstevel@tonic-gate #include <sys/types.h>
397c478bd9Sstevel@tonic-gate #include <sys/param.h>
407c478bd9Sstevel@tonic-gate #include <sys/lofi.h>
417c478bd9Sstevel@tonic-gate #include <sys/stat.h>
424058a205Sjrgn.keil@googlemail.com #include <sys/sysmacros.h>
4335f80dcbSToomas Soome #include <sys/modctl.h>
4487117650Saalok #include <netinet/in.h>
457c478bd9Sstevel@tonic-gate #include <stdio.h>
467c478bd9Sstevel@tonic-gate #include <fcntl.h>
477c478bd9Sstevel@tonic-gate #include <locale.h>
487c478bd9Sstevel@tonic-gate #include <string.h>
4987117650Saalok #include <strings.h>
507c478bd9Sstevel@tonic-gate #include <errno.h>
517c478bd9Sstevel@tonic-gate #include <stdlib.h>
527c478bd9Sstevel@tonic-gate #include <unistd.h>
537c478bd9Sstevel@tonic-gate #include <stropts.h>
541d8ed0f0Svikram #include <libdevinfo.h>
5587117650Saalok #include <libgen.h>
5687117650Saalok #include <ctype.h>
57579df0adSaalok #include <dlfcn.h>
587d82f0f8SDina K Nimeh #include <limits.h>
597d82f0f8SDina K Nimeh #include <security/cryptoki.h>
607d82f0f8SDina K Nimeh #include <cryptoutil.h>
617d82f0f8SDina K Nimeh #include <sys/crypto/ioctl.h>
627d82f0f8SDina K Nimeh #include <sys/crypto/ioctladmin.h>
63406fc510SToomas Soome #include <sys/cmlb.h>
64406fc510SToomas Soome #include <sys/mkdev.h>
657c478bd9Sstevel@tonic-gate #include "utils.h"
66b1efbcd6SAlok Aggarwal #include <LzmaEnc.h>
677c478bd9Sstevel@tonic-gate
687d82f0f8SDina K Nimeh /* Only need the IV len #defines out of these files, nothing else. */
697d82f0f8SDina K Nimeh #include <aes/aes_impl.h>
707d82f0f8SDina K Nimeh #include <des/des_impl.h>
717d82f0f8SDina K Nimeh #include <blowfish/blowfish_impl.h>
727d82f0f8SDina K Nimeh
737c478bd9Sstevel@tonic-gate static const char USAGE[] =
74406fc510SToomas Soome "Usage: %s [-r] [-l] -a file [ device ]\n"
75795f5a90SMohamed A. Khalfella " %s [-r] -c crypto_algorithm -a file [device]\n"
76795f5a90SMohamed A. Khalfella " %s [-r] -c crypto_algorithm -k raw_key_file -a file [device]\n"
77795f5a90SMohamed A. Khalfella " %s [-r] -c crypto_algorithm -T [token]:[manuf]:[serial]:key "
78795f5a90SMohamed A. Khalfella "-a file [device]\n"
79795f5a90SMohamed A. Khalfella " %s [-r] -c crypto_algorithm -T [token]:[manuf]:[serial]:key "
80795f5a90SMohamed A. Khalfella "-k wrapped_key_file -a file [device]\n"
81795f5a90SMohamed A. Khalfella " %s [-r] -c crypto_algorithm -e -a file [device]\n"
827c478bd9Sstevel@tonic-gate " %s -d file | device\n"
83b1efbcd6SAlok Aggarwal " %s -C [gzip|gzip-6|gzip-9|lzma] [-s segment_size] file\n"
8487117650Saalok " %s -U file\n"
85f9153c6bSDina K Nimeh " %s [ file | device ]\n";
867c478bd9Sstevel@tonic-gate
877d82f0f8SDina K Nimeh typedef struct token_spec {
887d82f0f8SDina K Nimeh char *name;
897d82f0f8SDina K Nimeh char *mfr;
907d82f0f8SDina K Nimeh char *serno;
917d82f0f8SDina K Nimeh char *key;
927d82f0f8SDina K Nimeh } token_spec_t;
937d82f0f8SDina K Nimeh
947d82f0f8SDina K Nimeh typedef struct mech_alias {
957d82f0f8SDina K Nimeh char *alias;
967d82f0f8SDina K Nimeh CK_MECHANISM_TYPE type;
977d82f0f8SDina K Nimeh char *name; /* for ioctl */
987d82f0f8SDina K Nimeh char *iv_name; /* for ioctl */
997d82f0f8SDina K Nimeh size_t iv_len; /* for ioctl */
1007d82f0f8SDina K Nimeh iv_method_t iv_type; /* for ioctl */
1017d82f0f8SDina K Nimeh size_t min_keysize; /* in bytes */
1027d82f0f8SDina K Nimeh size_t max_keysize; /* in bytes */
1037d82f0f8SDina K Nimeh token_spec_t *token;
1047d82f0f8SDina K Nimeh CK_SLOT_ID slot;
1057d82f0f8SDina K Nimeh } mech_alias_t;
1067d82f0f8SDina K Nimeh
1077d82f0f8SDina K Nimeh static mech_alias_t mech_aliases[] = {
1087d82f0f8SDina K Nimeh /* Preferred one should always be listed first. */
1097d82f0f8SDina K Nimeh { "aes-256-cbc", CKM_AES_CBC, "CKM_AES_CBC", "CKM_AES_ECB", AES_IV_LEN,
1107d82f0f8SDina K Nimeh IVM_ENC_BLKNO, ULONG_MAX, 0L, NULL, (CK_SLOT_ID) -1 },
1117d82f0f8SDina K Nimeh { "aes-192-cbc", CKM_AES_CBC, "CKM_AES_CBC", "CKM_AES_ECB", AES_IV_LEN,
1127d82f0f8SDina K Nimeh IVM_ENC_BLKNO, ULONG_MAX, 0L, NULL, (CK_SLOT_ID) -1 },
1137d82f0f8SDina K Nimeh { "aes-128-cbc", CKM_AES_CBC, "CKM_AES_CBC", "CKM_AES_ECB", AES_IV_LEN,
1147d82f0f8SDina K Nimeh IVM_ENC_BLKNO, ULONG_MAX, 0L, NULL, (CK_SLOT_ID) -1 },
1157d82f0f8SDina K Nimeh { "des3-cbc", CKM_DES3_CBC, "CKM_DES3_CBC", "CKM_DES3_ECB", DES_IV_LEN,
1167d82f0f8SDina K Nimeh IVM_ENC_BLKNO, ULONG_MAX, 0L, NULL, (CK_SLOT_ID)-1 },
1177d82f0f8SDina K Nimeh { "blowfish-cbc", CKM_BLOWFISH_CBC, "CKM_BLOWFISH_CBC",
1187d82f0f8SDina K Nimeh "CKM_BLOWFISH_ECB", BLOWFISH_IV_LEN, IVM_ENC_BLKNO, ULONG_MAX,
1197d82f0f8SDina K Nimeh 0L, NULL, (CK_SLOT_ID)-1 }
1207d82f0f8SDina K Nimeh /*
1217d82f0f8SDina K Nimeh * A cipher without an iv requirement would look like this:
1227d82f0f8SDina K Nimeh * { "aes-xex", CKM_AES_XEX, "CKM_AES_XEX", NULL, 0,
1237d82f0f8SDina K Nimeh * IVM_NONE, ULONG_MAX, 0L, NULL, (CK_SLOT_ID)-1 }
1247d82f0f8SDina K Nimeh */
1257d82f0f8SDina K Nimeh };
1267d82f0f8SDina K Nimeh
1277d82f0f8SDina K Nimeh int mech_aliases_count = (sizeof (mech_aliases) / sizeof (mech_alias_t));
1287d82f0f8SDina K Nimeh
1297d82f0f8SDina K Nimeh /* Preferred cipher, if one isn't specified on command line. */
1307d82f0f8SDina K Nimeh #define DEFAULT_CIPHER (&mech_aliases[0])
1317d82f0f8SDina K Nimeh
1327d82f0f8SDina K Nimeh #define DEFAULT_CIPHER_NUM 64 /* guess # kernel ciphers available */
1337d82f0f8SDina K Nimeh #define DEFAULT_MECHINFO_NUM 16 /* guess # kernel mechs available */
1347d82f0f8SDina K Nimeh #define MIN_PASSLEN 8 /* min acceptable passphrase size */
1357c478bd9Sstevel@tonic-gate
13687117650Saalok static int gzip_compress(void *src, size_t srclen, void *dst,
13787117650Saalok size_t *destlen, int level);
138b1efbcd6SAlok Aggarwal static int lzma_compress(void *src, size_t srclen, void *dst,
139b1efbcd6SAlok Aggarwal size_t *destlen, int level);
14087117650Saalok
14187117650Saalok lofi_compress_info_t lofi_compress_table[LOFI_COMPRESS_FUNCTIONS] = {
14287117650Saalok {NULL, gzip_compress, 6, "gzip"}, /* default */
14387117650Saalok {NULL, gzip_compress, 6, "gzip-6"},
144b1efbcd6SAlok Aggarwal {NULL, gzip_compress, 9, "gzip-9"},
145b1efbcd6SAlok Aggarwal {NULL, lzma_compress, 0, "lzma"}
14687117650Saalok };
14787117650Saalok
1487d82f0f8SDina K Nimeh /* For displaying lofi mappings */
14987117650Saalok #define FORMAT "%-20s %-30s %s\n"
1507d82f0f8SDina K Nimeh
15187117650Saalok #define COMPRESS_ALGORITHM "gzip"
15287117650Saalok #define COMPRESS_THRESHOLD 2048
15387117650Saalok #define SEGSIZE 131072
15487117650Saalok #define BLOCK_SIZE 512
15587117650Saalok #define KILOBYTE 1024
15687117650Saalok #define MEGABYTE (KILOBYTE * KILOBYTE)
15787117650Saalok #define GIGABYTE (KILOBYTE * MEGABYTE)
1586e096e64SGary Mills #define LIBZ "libz.so.1"
159579df0adSaalok
160a1b1a2a0SAndrey Sokolov const char lofi_crypto_magic[6] = LOFI_CRYPTO_MAGIC;
161a1b1a2a0SAndrey Sokolov
162b1efbcd6SAlok Aggarwal static void
usage(const char * pname)163b1efbcd6SAlok Aggarwal usage(const char *pname)
16487117650Saalok {
165b1efbcd6SAlok Aggarwal (void) fprintf(stderr, gettext(USAGE), pname, pname, pname,
166795f5a90SMohamed A. Khalfella pname, pname, pname, pname, pname, pname, pname);
167b1efbcd6SAlok Aggarwal exit(E_USAGE);
168b1efbcd6SAlok Aggarwal }
169b1efbcd6SAlok Aggarwal
170b1efbcd6SAlok Aggarwal static int
gzip_compress(void * src,size_t srclen,void * dst,size_t * dstlen,int level)171b1efbcd6SAlok Aggarwal gzip_compress(void *src, size_t srclen, void *dst, size_t *dstlen, int level)
172b1efbcd6SAlok Aggarwal {
173b1efbcd6SAlok Aggarwal static int (*compress2p)(void *, ulong_t *, void *, size_t, int) = NULL;
174579df0adSaalok void *libz_hdl = NULL;
17587117650Saalok
176579df0adSaalok /*
177579df0adSaalok * The first time we are called, attempt to dlopen()
1786e096e64SGary Mills * libz.so.1 and get a pointer to the compress2() function
179579df0adSaalok */
180579df0adSaalok if (compress2p == NULL) {
181579df0adSaalok if ((libz_hdl = openlib(LIBZ)) == NULL)
182579df0adSaalok die(gettext("could not find %s. "
183579df0adSaalok "gzip compression unavailable\n"), LIBZ);
184579df0adSaalok
185579df0adSaalok if ((compress2p =
186579df0adSaalok (int (*)(void *, ulong_t *, void *, size_t, int))
187579df0adSaalok dlsym(libz_hdl, "compress2")) == NULL) {
188579df0adSaalok closelib();
189579df0adSaalok die(gettext("could not find the correct %s. "
190579df0adSaalok "gzip compression unavailable\n"), LIBZ);
191579df0adSaalok }
192579df0adSaalok }
193579df0adSaalok
194579df0adSaalok if ((*compress2p)(dst, (ulong_t *)dstlen, src, srclen, level) != 0)
195579df0adSaalok return (-1);
19687117650Saalok return (0);
19787117650Saalok }
1987c478bd9Sstevel@tonic-gate
199b1efbcd6SAlok Aggarwal /*ARGSUSED*/
2007c478bd9Sstevel@tonic-gate static void
SzAlloc(void * p,size_t size)201b1efbcd6SAlok Aggarwal *SzAlloc(void *p, size_t size)
2027c478bd9Sstevel@tonic-gate {
203b1efbcd6SAlok Aggarwal return (malloc(size));
204b1efbcd6SAlok Aggarwal }
205b1efbcd6SAlok Aggarwal
206b1efbcd6SAlok Aggarwal /*ARGSUSED*/
207b1efbcd6SAlok Aggarwal static void
SzFree(void * p,void * address,size_t size)208b1efbcd6SAlok Aggarwal SzFree(void *p, void *address, size_t size)
209b1efbcd6SAlok Aggarwal {
210b1efbcd6SAlok Aggarwal free(address);
211b1efbcd6SAlok Aggarwal }
212b1efbcd6SAlok Aggarwal
213b1efbcd6SAlok Aggarwal static ISzAlloc g_Alloc = {
214b1efbcd6SAlok Aggarwal SzAlloc,
215b1efbcd6SAlok Aggarwal SzFree
216b1efbcd6SAlok Aggarwal };
217b1efbcd6SAlok Aggarwal
218b1efbcd6SAlok Aggarwal #define LZMA_UNCOMPRESSED_SIZE 8
219b1efbcd6SAlok Aggarwal #define LZMA_HEADER_SIZE (LZMA_PROPS_SIZE + LZMA_UNCOMPRESSED_SIZE)
220b1efbcd6SAlok Aggarwal
221b1efbcd6SAlok Aggarwal /*ARGSUSED*/
222b1efbcd6SAlok Aggarwal static int
lzma_compress(void * src,size_t srclen,void * dst,size_t * dstlen,int level)223b1efbcd6SAlok Aggarwal lzma_compress(void *src, size_t srclen, void *dst,
224b1efbcd6SAlok Aggarwal size_t *dstlen, int level)
225b1efbcd6SAlok Aggarwal {
226b1efbcd6SAlok Aggarwal CLzmaEncProps props;
227b1efbcd6SAlok Aggarwal size_t outsize2;
228b1efbcd6SAlok Aggarwal size_t outsizeprocessed;
229b1efbcd6SAlok Aggarwal size_t outpropssize = LZMA_PROPS_SIZE;
230b1efbcd6SAlok Aggarwal uint64_t t = 0;
231b1efbcd6SAlok Aggarwal SRes res;
232b1efbcd6SAlok Aggarwal Byte *dstp;
233b1efbcd6SAlok Aggarwal int i;
234b1efbcd6SAlok Aggarwal
235b1efbcd6SAlok Aggarwal outsize2 = *dstlen;
236b1efbcd6SAlok Aggarwal
237b1efbcd6SAlok Aggarwal LzmaEncProps_Init(&props);
238b1efbcd6SAlok Aggarwal
239b1efbcd6SAlok Aggarwal /*
240b1efbcd6SAlok Aggarwal * The LZMA compressed file format is as follows -
241b1efbcd6SAlok Aggarwal *
242b1efbcd6SAlok Aggarwal * Offset Size(bytes) Description
243b1efbcd6SAlok Aggarwal * 0 1 LZMA properties (lc, lp, lp (encoded))
244b1efbcd6SAlok Aggarwal * 1 4 Dictionary size (little endian)
245b1efbcd6SAlok Aggarwal * 5 8 Uncompressed size (little endian)
246b1efbcd6SAlok Aggarwal * 13 Compressed data
247b1efbcd6SAlok Aggarwal */
248b1efbcd6SAlok Aggarwal
249b1efbcd6SAlok Aggarwal /* set the dictionary size to be 8MB */
250b1efbcd6SAlok Aggarwal props.dictSize = 1 << 23;
251b1efbcd6SAlok Aggarwal
252b1efbcd6SAlok Aggarwal if (*dstlen < LZMA_HEADER_SIZE)
253b1efbcd6SAlok Aggarwal return (SZ_ERROR_OUTPUT_EOF);
254b1efbcd6SAlok Aggarwal
255b1efbcd6SAlok Aggarwal dstp = (Byte *)dst;
256b1efbcd6SAlok Aggarwal t = srclen;
257b1efbcd6SAlok Aggarwal /*
258b1efbcd6SAlok Aggarwal * Set the uncompressed size in the LZMA header
259b1efbcd6SAlok Aggarwal * The LZMA properties (specified in 'props')
260b1efbcd6SAlok Aggarwal * will be set by the call to LzmaEncode()
261b1efbcd6SAlok Aggarwal */
262b1efbcd6SAlok Aggarwal for (i = 0; i < LZMA_UNCOMPRESSED_SIZE; i++, t >>= 8) {
263b1efbcd6SAlok Aggarwal dstp[LZMA_PROPS_SIZE + i] = (Byte)t;
264b1efbcd6SAlok Aggarwal }
265b1efbcd6SAlok Aggarwal
266b1efbcd6SAlok Aggarwal outsizeprocessed = outsize2 - LZMA_HEADER_SIZE;
267b1efbcd6SAlok Aggarwal res = LzmaEncode(dstp + LZMA_HEADER_SIZE, &outsizeprocessed,
268b1efbcd6SAlok Aggarwal src, srclen, &props, dstp, &outpropssize, 0, NULL,
269b1efbcd6SAlok Aggarwal &g_Alloc, &g_Alloc);
270b1efbcd6SAlok Aggarwal
271b1efbcd6SAlok Aggarwal if (res != 0)
272b1efbcd6SAlok Aggarwal return (-1);
273b1efbcd6SAlok Aggarwal
274b1efbcd6SAlok Aggarwal *dstlen = outsizeprocessed + LZMA_HEADER_SIZE;
275b1efbcd6SAlok Aggarwal return (0);
2767c478bd9Sstevel@tonic-gate }
2777c478bd9Sstevel@tonic-gate
2787c478bd9Sstevel@tonic-gate /*
2797c478bd9Sstevel@tonic-gate * Translate a lofi device name to a minor number. We might be asked
2807c478bd9Sstevel@tonic-gate * to do this when there is no association (such as when the user specifies
2817c478bd9Sstevel@tonic-gate * a particular device), so we can only look at the string.
2827c478bd9Sstevel@tonic-gate */
2837c478bd9Sstevel@tonic-gate static int
name_to_minor(const char * devicename)2847c478bd9Sstevel@tonic-gate name_to_minor(const char *devicename)
2857c478bd9Sstevel@tonic-gate {
286406fc510SToomas Soome struct stat st;
2877c478bd9Sstevel@tonic-gate
288406fc510SToomas Soome /*
289406fc510SToomas Soome * If devicename does not exist, then devicename contains
290406fc510SToomas Soome * the name of the device to be created.
291406fc510SToomas Soome * Note we only allow non-labeled devices here.
292406fc510SToomas Soome */
293406fc510SToomas Soome if (stat(devicename, &st)) {
294406fc510SToomas Soome int minor, rv;
295406fc510SToomas Soome
296406fc510SToomas Soome rv = sscanf(devicename, "/dev/" LOFI_BLOCK_NAME "/%d", &minor);
297406fc510SToomas Soome if (rv == 1)
2987c478bd9Sstevel@tonic-gate return (minor);
299406fc510SToomas Soome rv = sscanf(devicename, "/dev/" LOFI_CHAR_NAME "/%d", &minor);
300406fc510SToomas Soome if (rv == 1)
3017c478bd9Sstevel@tonic-gate return (minor);
302406fc510SToomas Soome
303406fc510SToomas Soome return (0);
3047c478bd9Sstevel@tonic-gate }
305406fc510SToomas Soome
30635f80dcbSToomas Soome /*
30735f80dcbSToomas Soome * For disk devices we use modctl(MODGETNAME) to read driver name
30835f80dcbSToomas Soome * for major device.
30935f80dcbSToomas Soome */
310406fc510SToomas Soome if (st.st_mode & S_IFCHR || st.st_mode & S_IFBLK) {
31135f80dcbSToomas Soome major_t maj;
31235f80dcbSToomas Soome char mname[MODMAXNAMELEN];
31335f80dcbSToomas Soome
31435f80dcbSToomas Soome maj = major(st.st_rdev);
31535f80dcbSToomas Soome
31635f80dcbSToomas Soome if (modctl(MODGETNAME, mname, MODMAXNAMELEN, &maj) == 0) {
31735f80dcbSToomas Soome if (strncmp(mname, LOFI_DRIVER_NAME,
31835f80dcbSToomas Soome sizeof (LOFI_DRIVER_NAME)) == 0) {
319406fc510SToomas Soome return (LOFI_MINOR2ID(minor(st.st_rdev)));
320406fc510SToomas Soome }
32135f80dcbSToomas Soome }
32235f80dcbSToomas Soome }
323406fc510SToomas Soome
3247c478bd9Sstevel@tonic-gate return (0);
3257c478bd9Sstevel@tonic-gate }
3267c478bd9Sstevel@tonic-gate
3277c478bd9Sstevel@tonic-gate /*
3287c478bd9Sstevel@tonic-gate * This might be the first time we've used this minor number. If so,
3297c478bd9Sstevel@tonic-gate * it might also be that the /dev links are in the process of being created
3307c478bd9Sstevel@tonic-gate * by devfsadmd (or that they'll be created "soon"). We cannot return
3317c478bd9Sstevel@tonic-gate * until they're there or the invoker of lofiadm might try to use them
3327c478bd9Sstevel@tonic-gate * and not find them. This can happen if a shell script is running on
3337c478bd9Sstevel@tonic-gate * an MP.
3347c478bd9Sstevel@tonic-gate */
3357c478bd9Sstevel@tonic-gate static int sleeptime = 2; /* number of seconds to sleep between stat's */
3367c478bd9Sstevel@tonic-gate static int maxsleep = 120; /* maximum number of seconds to sleep */
3377c478bd9Sstevel@tonic-gate
3387c478bd9Sstevel@tonic-gate static void
make_blkdevname(struct lofi_ioctl * li,char * path,size_t len)339406fc510SToomas Soome make_blkdevname(struct lofi_ioctl *li, char *path, size_t len)
340406fc510SToomas Soome {
341406fc510SToomas Soome char *r1, *r2;
342406fc510SToomas Soome size_t l1;
343406fc510SToomas Soome
344406fc510SToomas Soome if (li->li_devpath[0] == '\0') {
345406fc510SToomas Soome if (li->li_labeled)
346406fc510SToomas Soome (void) strlcpy(path, "unknown", len);
347406fc510SToomas Soome else
348406fc510SToomas Soome (void) snprintf(path, len,
349406fc510SToomas Soome "/dev/" LOFI_BLOCK_NAME "/%d", li->li_id);
350406fc510SToomas Soome return;
351406fc510SToomas Soome }
352406fc510SToomas Soome (void) strlcpy(path, li->li_devpath, len);
353406fc510SToomas Soome r1 = strchr(path, 'r');
354406fc510SToomas Soome l1 = r1 - path;
355406fc510SToomas Soome r2 = strchr(li->li_devpath, 'r');
356406fc510SToomas Soome (void) strlcpy(r1, r2+1, len - l1);
357406fc510SToomas Soome
358406fc510SToomas Soome if (li->li_labeled) {
359406fc510SToomas Soome (void) strlcat(path, "p0", len);
360406fc510SToomas Soome }
361406fc510SToomas Soome }
362406fc510SToomas Soome
363406fc510SToomas Soome static void
wait_until_dev_complete(struct lofi_ioctl * li)364406fc510SToomas Soome wait_until_dev_complete(struct lofi_ioctl *li)
3657c478bd9Sstevel@tonic-gate {
3667c478bd9Sstevel@tonic-gate struct stat64 buf;
3677c478bd9Sstevel@tonic-gate int cursleep;
36887117650Saalok char blkpath[MAXPATHLEN];
36987117650Saalok char charpath[MAXPATHLEN];
3701d8ed0f0Svikram di_devlink_handle_t hdl;
3711d8ed0f0Svikram
372406fc510SToomas Soome make_blkdevname(li, blkpath, sizeof (blkpath));
373406fc510SToomas Soome (void) strlcpy(charpath, li->li_devpath, sizeof (charpath));
374406fc510SToomas Soome
375406fc510SToomas Soome if (li->li_labeled) {
376406fc510SToomas Soome (void) strlcat(charpath, "p0", sizeof (charpath));
377406fc510SToomas Soome }
3781d8ed0f0Svikram
3791d8ed0f0Svikram /* Check if links already present */
3801d8ed0f0Svikram if (stat64(blkpath, &buf) == 0 && stat64(charpath, &buf) == 0)
3811d8ed0f0Svikram return;
3821d8ed0f0Svikram
3831d8ed0f0Svikram /* First use di_devlink_init() */
3841d8ed0f0Svikram if (hdl = di_devlink_init("lofi", DI_MAKE_LINK)) {
3851d8ed0f0Svikram (void) di_devlink_fini(&hdl);
3861d8ed0f0Svikram goto out;
3871d8ed0f0Svikram }
3881d8ed0f0Svikram
3891d8ed0f0Svikram /*
3901d8ed0f0Svikram * Under normal conditions, di_devlink_init(DI_MAKE_LINK) above will
3911d8ed0f0Svikram * only fail if the caller is non-root. In that case, wait for
3921d8ed0f0Svikram * link creation via sysevents.
3931d8ed0f0Svikram */
3947d82f0f8SDina K Nimeh for (cursleep = 0; cursleep < maxsleep; cursleep += sleeptime) {
3957d82f0f8SDina K Nimeh if (stat64(blkpath, &buf) == 0 && stat64(charpath, &buf) == 0)
3967c478bd9Sstevel@tonic-gate return;
3977d82f0f8SDina K Nimeh (void) sleep(sleeptime);
3987c478bd9Sstevel@tonic-gate }
3991d8ed0f0Svikram
4007c478bd9Sstevel@tonic-gate /* one last try */
4011d8ed0f0Svikram out:
4027c478bd9Sstevel@tonic-gate if (stat64(blkpath, &buf) == -1) {
4037c478bd9Sstevel@tonic-gate die(gettext("%s was not created"), blkpath);
4047c478bd9Sstevel@tonic-gate }
4057c478bd9Sstevel@tonic-gate if (stat64(charpath, &buf) == -1) {
4067c478bd9Sstevel@tonic-gate die(gettext("%s was not created"), charpath);
4077c478bd9Sstevel@tonic-gate }
4087c478bd9Sstevel@tonic-gate }
4097c478bd9Sstevel@tonic-gate
4107c478bd9Sstevel@tonic-gate /*
4117d82f0f8SDina K Nimeh * Map the file and return the minor number the driver picked for the file
4127d82f0f8SDina K Nimeh * DO NOT use this function if the filename is actually the device name.
4137d82f0f8SDina K Nimeh */
4147d82f0f8SDina K Nimeh static int
lofi_map_file(int lfd,struct lofi_ioctl * li,const char * filename)415406fc510SToomas Soome lofi_map_file(int lfd, struct lofi_ioctl *li, const char *filename)
4167d82f0f8SDina K Nimeh {
4177d82f0f8SDina K Nimeh int minor;
4187d82f0f8SDina K Nimeh
419406fc510SToomas Soome li->li_id = 0;
420406fc510SToomas Soome (void) strlcpy(li->li_filename, filename, sizeof (li->li_filename));
421406fc510SToomas Soome minor = ioctl(lfd, LOFI_MAP_FILE, li);
4227d82f0f8SDina K Nimeh if (minor == -1) {
4237d82f0f8SDina K Nimeh if (errno == ENOTSUP)
4247d82f0f8SDina K Nimeh warn(gettext("encrypting compressed files is "
4257d82f0f8SDina K Nimeh "unsupported"));
4267d82f0f8SDina K Nimeh die(gettext("could not map file %s"), filename);
4277d82f0f8SDina K Nimeh }
428406fc510SToomas Soome wait_until_dev_complete(li);
4297d82f0f8SDina K Nimeh return (minor);
4307d82f0f8SDina K Nimeh }
4317d82f0f8SDina K Nimeh
4327d82f0f8SDina K Nimeh /*
4337c478bd9Sstevel@tonic-gate * Add a device association. If devicename is NULL, let the driver
4347c478bd9Sstevel@tonic-gate * pick a device.
4357c478bd9Sstevel@tonic-gate */
4367c478bd9Sstevel@tonic-gate static void
add_mapping(int lfd,const char * devicename,const char * filename,mech_alias_t * cipher,const char * rkey,size_t rksz,boolean_t rdonly,boolean_t label)43787117650Saalok add_mapping(int lfd, const char *devicename, const char *filename,
438406fc510SToomas Soome mech_alias_t *cipher, const char *rkey, size_t rksz, boolean_t rdonly,
439406fc510SToomas Soome boolean_t label)
4407c478bd9Sstevel@tonic-gate {
4417c478bd9Sstevel@tonic-gate struct lofi_ioctl li;
4427d82f0f8SDina K Nimeh
443406fc510SToomas Soome bzero(&li, sizeof (li));
444cd69fabeSAlexander Eremin li.li_readonly = rdonly;
445406fc510SToomas Soome li.li_labeled = label;
446cd69fabeSAlexander Eremin
4477d82f0f8SDina K Nimeh li.li_crypto_enabled = B_FALSE;
4487d82f0f8SDina K Nimeh if (cipher != NULL) {
4497d82f0f8SDina K Nimeh /* set up encryption for mapped file */
4507d82f0f8SDina K Nimeh li.li_crypto_enabled = B_TRUE;
4517d82f0f8SDina K Nimeh (void) strlcpy(li.li_cipher, cipher->name,
4527d82f0f8SDina K Nimeh sizeof (li.li_cipher));
4537d82f0f8SDina K Nimeh if (rksz > sizeof (li.li_key)) {
4547d82f0f8SDina K Nimeh die(gettext("key too large"));
4557d82f0f8SDina K Nimeh }
4567d82f0f8SDina K Nimeh bcopy(rkey, li.li_key, rksz);
4577d82f0f8SDina K Nimeh li.li_key_len = rksz << 3; /* convert to bits */
4587d82f0f8SDina K Nimeh
4597d82f0f8SDina K Nimeh li.li_iv_type = cipher->iv_type;
4607d82f0f8SDina K Nimeh li.li_iv_len = cipher->iv_len; /* 0 when no iv needed */
4617d82f0f8SDina K Nimeh switch (cipher->iv_type) {
4627d82f0f8SDina K Nimeh case IVM_ENC_BLKNO:
4637d82f0f8SDina K Nimeh (void) strlcpy(li.li_iv_cipher, cipher->iv_name,
4647d82f0f8SDina K Nimeh sizeof (li.li_iv_cipher));
4657d82f0f8SDina K Nimeh break;
4667d82f0f8SDina K Nimeh case IVM_NONE:
4677d82f0f8SDina K Nimeh /* FALLTHROUGH */
4687d82f0f8SDina K Nimeh default:
4697d82f0f8SDina K Nimeh break;
4707d82f0f8SDina K Nimeh }
4717d82f0f8SDina K Nimeh }
4727c478bd9Sstevel@tonic-gate
4737c478bd9Sstevel@tonic-gate if (devicename == NULL) {
4747d82f0f8SDina K Nimeh int minor;
475406fc510SToomas Soome char path[MAXPATHLEN];
47687117650Saalok
4777d82f0f8SDina K Nimeh /* pick one via the driver */
478406fc510SToomas Soome minor = lofi_map_file(lfd, &li, filename);
479406fc510SToomas Soome if (minor > 0) {
480406fc510SToomas Soome make_blkdevname(&li, path, sizeof (path));
481406fc510SToomas Soome
4827d82f0f8SDina K Nimeh /* if mapping succeeds, print the one picked */
483406fc510SToomas Soome (void) printf("%s\n", path);
484406fc510SToomas Soome }
4857c478bd9Sstevel@tonic-gate return;
4867c478bd9Sstevel@tonic-gate }
4877d82f0f8SDina K Nimeh
4887c478bd9Sstevel@tonic-gate /* use device we were given */
489406fc510SToomas Soome li.li_id = name_to_minor(devicename);
490406fc510SToomas Soome if (li.li_id == 0) {
4917c478bd9Sstevel@tonic-gate die(gettext("malformed device name %s\n"), devicename);
4927c478bd9Sstevel@tonic-gate }
49387117650Saalok (void) strlcpy(li.li_filename, filename, sizeof (li.li_filename));
4947d82f0f8SDina K Nimeh
4957d82f0f8SDina K Nimeh /* if device is already in use li.li_minor won't change */
4967c478bd9Sstevel@tonic-gate if (ioctl(lfd, LOFI_MAP_FILE_MINOR, &li) == -1) {
4977d82f0f8SDina K Nimeh if (errno == ENOTSUP)
4987d82f0f8SDina K Nimeh warn(gettext("encrypting compressed files is "
4997d82f0f8SDina K Nimeh "unsupported"));
5007c478bd9Sstevel@tonic-gate die(gettext("could not map file %s to %s"), filename,
5017c478bd9Sstevel@tonic-gate devicename);
5027c478bd9Sstevel@tonic-gate }
503406fc510SToomas Soome wait_until_dev_complete(&li);
5047c478bd9Sstevel@tonic-gate }
5057c478bd9Sstevel@tonic-gate
5067c478bd9Sstevel@tonic-gate /*
5077c478bd9Sstevel@tonic-gate * Remove an association. Delete by device name if non-NULL, or by
5087c478bd9Sstevel@tonic-gate * filename otherwise.
5097c478bd9Sstevel@tonic-gate */
5107c478bd9Sstevel@tonic-gate static void
delete_mapping(int lfd,const char * devicename,const char * filename,boolean_t force)5113d7072f8Seschrock delete_mapping(int lfd, const char *devicename, const char *filename,
5123d7072f8Seschrock boolean_t force)
5137c478bd9Sstevel@tonic-gate {
5147c478bd9Sstevel@tonic-gate struct lofi_ioctl li;
5157c478bd9Sstevel@tonic-gate
5163d7072f8Seschrock li.li_force = force;
51793239addSjohnlev li.li_cleanup = B_FALSE;
51893239addSjohnlev
5197c478bd9Sstevel@tonic-gate if (devicename == NULL) {
5207c478bd9Sstevel@tonic-gate /* delete by filename */
52187117650Saalok (void) strlcpy(li.li_filename, filename,
52287117650Saalok sizeof (li.li_filename));
523406fc510SToomas Soome li.li_id = 0;
5247c478bd9Sstevel@tonic-gate if (ioctl(lfd, LOFI_UNMAP_FILE, &li) == -1) {
5257c478bd9Sstevel@tonic-gate die(gettext("could not unmap file %s"), filename);
5267c478bd9Sstevel@tonic-gate }
5277c478bd9Sstevel@tonic-gate return;
5287c478bd9Sstevel@tonic-gate }
5297c478bd9Sstevel@tonic-gate
530f9153c6bSDina K Nimeh /* delete by device */
531406fc510SToomas Soome li.li_id = name_to_minor(devicename);
532406fc510SToomas Soome if (li.li_id == 0) {
5337c478bd9Sstevel@tonic-gate die(gettext("malformed device name %s\n"), devicename);
5347c478bd9Sstevel@tonic-gate }
5357c478bd9Sstevel@tonic-gate if (ioctl(lfd, LOFI_UNMAP_FILE_MINOR, &li) == -1) {
5367c478bd9Sstevel@tonic-gate die(gettext("could not unmap device %s"), devicename);
5377c478bd9Sstevel@tonic-gate }
5387c478bd9Sstevel@tonic-gate }
5397c478bd9Sstevel@tonic-gate
5407d82f0f8SDina K Nimeh /*
5417d82f0f8SDina K Nimeh * Show filename given devicename, or devicename given filename.
5427d82f0f8SDina K Nimeh */
5437c478bd9Sstevel@tonic-gate static void
print_one_mapping(int lfd,const char * devicename,const char * filename)5447c478bd9Sstevel@tonic-gate print_one_mapping(int lfd, const char *devicename, const char *filename)
5457c478bd9Sstevel@tonic-gate {
5467c478bd9Sstevel@tonic-gate struct lofi_ioctl li;
547406fc510SToomas Soome char blkpath[MAXPATHLEN];
5487c478bd9Sstevel@tonic-gate
5497c478bd9Sstevel@tonic-gate if (devicename == NULL) {
5507c478bd9Sstevel@tonic-gate /* given filename, print devicename */
551406fc510SToomas Soome li.li_id = 0;
55287117650Saalok (void) strlcpy(li.li_filename, filename,
55387117650Saalok sizeof (li.li_filename));
5547c478bd9Sstevel@tonic-gate if (ioctl(lfd, LOFI_GET_MINOR, &li) == -1) {
5557c478bd9Sstevel@tonic-gate die(gettext("could not find device for %s"), filename);
5567c478bd9Sstevel@tonic-gate }
557406fc510SToomas Soome make_blkdevname(&li, blkpath, sizeof (blkpath));
558406fc510SToomas Soome (void) printf("%s\n", blkpath);
5597c478bd9Sstevel@tonic-gate return;
5607c478bd9Sstevel@tonic-gate }
5617c478bd9Sstevel@tonic-gate
5627c478bd9Sstevel@tonic-gate /* given devicename, print filename */
563406fc510SToomas Soome li.li_id = name_to_minor(devicename);
564406fc510SToomas Soome if (li.li_id == 0) {
5657c478bd9Sstevel@tonic-gate die(gettext("malformed device name %s\n"), devicename);
5667c478bd9Sstevel@tonic-gate }
5677c478bd9Sstevel@tonic-gate if (ioctl(lfd, LOFI_GET_FILENAME, &li) == -1) {
5687c478bd9Sstevel@tonic-gate die(gettext("could not find filename for %s"), devicename);
5697c478bd9Sstevel@tonic-gate }
5707c478bd9Sstevel@tonic-gate (void) printf("%s\n", li.li_filename);
5717c478bd9Sstevel@tonic-gate }
5727c478bd9Sstevel@tonic-gate
57387117650Saalok /*
5747d82f0f8SDina K Nimeh * Print the list of all the mappings, including a header.
5757d82f0f8SDina K Nimeh */
5767d82f0f8SDina K Nimeh static void
print_mappings(int fd)5777d82f0f8SDina K Nimeh print_mappings(int fd)
5787d82f0f8SDina K Nimeh {
5797d82f0f8SDina K Nimeh struct lofi_ioctl li;
5807d82f0f8SDina K Nimeh int minor;
5817d82f0f8SDina K Nimeh int maxminor;
5827d82f0f8SDina K Nimeh char path[MAXPATHLEN];
583cd69fabeSAlexander Eremin char options[MAXPATHLEN] = { 0 };
5847d82f0f8SDina K Nimeh
585406fc510SToomas Soome li.li_id = 0;
5867d82f0f8SDina K Nimeh if (ioctl(fd, LOFI_GET_MAXMINOR, &li) == -1) {
5877d82f0f8SDina K Nimeh die("ioctl");
5887d82f0f8SDina K Nimeh }
589406fc510SToomas Soome maxminor = li.li_id;
5907d82f0f8SDina K Nimeh
5917d82f0f8SDina K Nimeh (void) printf(FORMAT, gettext("Block Device"), gettext("File"),
5927d82f0f8SDina K Nimeh gettext("Options"));
5937d82f0f8SDina K Nimeh for (minor = 1; minor <= maxminor; minor++) {
594406fc510SToomas Soome li.li_id = minor;
5957d82f0f8SDina K Nimeh if (ioctl(fd, LOFI_GET_FILENAME, &li) == -1) {
5967d82f0f8SDina K Nimeh if (errno == ENXIO)
5977d82f0f8SDina K Nimeh continue;
5987d82f0f8SDina K Nimeh warn("ioctl");
5997d82f0f8SDina K Nimeh break;
6007d82f0f8SDina K Nimeh }
601406fc510SToomas Soome make_blkdevname(&li, path, sizeof (path));
602cd69fabeSAlexander Eremin
603cd69fabeSAlexander Eremin options[0] = '\0';
604cd69fabeSAlexander Eremin
6057d82f0f8SDina K Nimeh /*
6067d82f0f8SDina K Nimeh * Encrypted lofi and compressed lofi are mutually exclusive.
6077d82f0f8SDina K Nimeh */
6087d82f0f8SDina K Nimeh if (li.li_crypto_enabled)
6097d82f0f8SDina K Nimeh (void) snprintf(options, sizeof (options),
6107d82f0f8SDina K Nimeh gettext("Encrypted"));
6117d82f0f8SDina K Nimeh else if (li.li_algorithm[0] != '\0')
6127d82f0f8SDina K Nimeh (void) snprintf(options, sizeof (options),
6137d82f0f8SDina K Nimeh gettext("Compressed(%s)"), li.li_algorithm);
614cd69fabeSAlexander Eremin if (li.li_readonly) {
615cd69fabeSAlexander Eremin if (strlen(options) != 0) {
616406fc510SToomas Soome (void) strlcat(options, ",Readonly",
617cd69fabeSAlexander Eremin sizeof (options));
618cd69fabeSAlexander Eremin } else {
619cd69fabeSAlexander Eremin (void) snprintf(options, sizeof (options),
620cd69fabeSAlexander Eremin gettext("Readonly"));
621cd69fabeSAlexander Eremin }
622cd69fabeSAlexander Eremin }
623406fc510SToomas Soome if (li.li_labeled) {
624406fc510SToomas Soome if (strlen(options) != 0) {
625406fc510SToomas Soome (void) strlcat(options, ",Labeled",
626406fc510SToomas Soome sizeof (options));
627406fc510SToomas Soome } else {
628406fc510SToomas Soome (void) snprintf(options, sizeof (options),
629406fc510SToomas Soome gettext("Labeled"));
630406fc510SToomas Soome }
631406fc510SToomas Soome }
632cd69fabeSAlexander Eremin if (strlen(options) == 0)
6337d82f0f8SDina K Nimeh (void) snprintf(options, sizeof (options), "-");
6347d82f0f8SDina K Nimeh
6357d82f0f8SDina K Nimeh (void) printf(FORMAT, path, li.li_filename, options);
6367d82f0f8SDina K Nimeh }
6377d82f0f8SDina K Nimeh }
6387d82f0f8SDina K Nimeh
6397d82f0f8SDina K Nimeh /*
6407d82f0f8SDina K Nimeh * Verify the cipher selected by user.
6417d82f0f8SDina K Nimeh */
6427d82f0f8SDina K Nimeh static mech_alias_t *
ciph2mech(const char * alias)6437d82f0f8SDina K Nimeh ciph2mech(const char *alias)
6447d82f0f8SDina K Nimeh {
6457d82f0f8SDina K Nimeh int i;
6467d82f0f8SDina K Nimeh
6477d82f0f8SDina K Nimeh for (i = 0; i < mech_aliases_count; i++) {
6487d82f0f8SDina K Nimeh if (strcasecmp(alias, mech_aliases[i].alias) == 0)
6497d82f0f8SDina K Nimeh return (&mech_aliases[i]);
6507d82f0f8SDina K Nimeh }
6517d82f0f8SDina K Nimeh return (NULL);
6527d82f0f8SDina K Nimeh }
6537d82f0f8SDina K Nimeh
6547d82f0f8SDina K Nimeh /*
6557d82f0f8SDina K Nimeh * Verify user selected cipher is also available in kernel.
6567d82f0f8SDina K Nimeh *
6577d82f0f8SDina K Nimeh * While traversing kernel list of mechs, if the cipher is supported in the
6587d82f0f8SDina K Nimeh * kernel for both encryption and decryption, it also picks up the min/max
6597d82f0f8SDina K Nimeh * key size.
6607d82f0f8SDina K Nimeh */
6617d82f0f8SDina K Nimeh static boolean_t
kernel_cipher_check(mech_alias_t * cipher)6627d82f0f8SDina K Nimeh kernel_cipher_check(mech_alias_t *cipher)
6637d82f0f8SDina K Nimeh {
6647d82f0f8SDina K Nimeh boolean_t ciph_ok = B_FALSE;
6657d82f0f8SDina K Nimeh boolean_t iv_ok = B_FALSE;
6667d82f0f8SDina K Nimeh int i;
6677d82f0f8SDina K Nimeh int count;
6687d82f0f8SDina K Nimeh crypto_get_mechanism_list_t *kciphers = NULL;
6697d82f0f8SDina K Nimeh crypto_get_all_mechanism_info_t *kinfo = NULL;
6707d82f0f8SDina K Nimeh int fd = -1;
6717d82f0f8SDina K Nimeh size_t keymin;
6727d82f0f8SDina K Nimeh size_t keymax;
6737d82f0f8SDina K Nimeh
6747d82f0f8SDina K Nimeh /* if cipher doesn't need iv generating mech, bypass that check now */
6757d82f0f8SDina K Nimeh if (cipher->iv_name == NULL)
6767d82f0f8SDina K Nimeh iv_ok = B_TRUE;
6777d82f0f8SDina K Nimeh
6787d82f0f8SDina K Nimeh /* allocate some space for the list of kernel ciphers */
6797d82f0f8SDina K Nimeh count = DEFAULT_CIPHER_NUM;
6807d82f0f8SDina K Nimeh kciphers = malloc(sizeof (crypto_get_mechanism_list_t) +
6817d82f0f8SDina K Nimeh sizeof (crypto_mech_name_t) * (count - 1));
6827d82f0f8SDina K Nimeh if (kciphers == NULL)
6837d82f0f8SDina K Nimeh die(gettext("failed to allocate memory for list of "
6847d82f0f8SDina K Nimeh "kernel mechanisms"));
6857d82f0f8SDina K Nimeh kciphers->ml_count = count;
6867d82f0f8SDina K Nimeh
6877d82f0f8SDina K Nimeh /* query crypto device to get list of kernel ciphers */
6887d82f0f8SDina K Nimeh if ((fd = open("/dev/crypto", O_RDWR)) == -1) {
6897d82f0f8SDina K Nimeh warn(gettext("failed to open %s"), "/dev/crypto");
6907d82f0f8SDina K Nimeh goto kcc_out;
6917d82f0f8SDina K Nimeh }
6927d82f0f8SDina K Nimeh
6937d82f0f8SDina K Nimeh if (ioctl(fd, CRYPTO_GET_MECHANISM_LIST, kciphers) == -1) {
6947d82f0f8SDina K Nimeh warn(gettext("CRYPTO_GET_MECHANISM_LIST ioctl failed"));
6957d82f0f8SDina K Nimeh goto kcc_out;
6967d82f0f8SDina K Nimeh }
6977d82f0f8SDina K Nimeh
6987d82f0f8SDina K Nimeh if (kciphers->ml_return_value == CRYPTO_BUFFER_TOO_SMALL) {
6997d82f0f8SDina K Nimeh count = kciphers->ml_count;
7007d82f0f8SDina K Nimeh free(kciphers);
7017d82f0f8SDina K Nimeh kciphers = malloc(sizeof (crypto_get_mechanism_list_t) +
7027d82f0f8SDina K Nimeh sizeof (crypto_mech_name_t) * (count - 1));
7037d82f0f8SDina K Nimeh if (kciphers == NULL) {
7047d82f0f8SDina K Nimeh warn(gettext("failed to allocate memory for list of "
7057d82f0f8SDina K Nimeh "kernel mechanisms"));
7067d82f0f8SDina K Nimeh goto kcc_out;
7077d82f0f8SDina K Nimeh }
7087d82f0f8SDina K Nimeh kciphers->ml_count = count;
7097d82f0f8SDina K Nimeh
7107d82f0f8SDina K Nimeh if (ioctl(fd, CRYPTO_GET_MECHANISM_LIST, kciphers) == -1) {
7117d82f0f8SDina K Nimeh warn(gettext("CRYPTO_GET_MECHANISM_LIST ioctl failed"));
7127d82f0f8SDina K Nimeh goto kcc_out;
7137d82f0f8SDina K Nimeh }
7147d82f0f8SDina K Nimeh }
7157d82f0f8SDina K Nimeh
7167d82f0f8SDina K Nimeh if (kciphers->ml_return_value != CRYPTO_SUCCESS) {
7177d82f0f8SDina K Nimeh warn(gettext(
7187d82f0f8SDina K Nimeh "CRYPTO_GET_MECHANISM_LIST ioctl return value = %d\n"),
7197d82f0f8SDina K Nimeh kciphers->ml_return_value);
7207d82f0f8SDina K Nimeh goto kcc_out;
7217d82f0f8SDina K Nimeh }
7227d82f0f8SDina K Nimeh
7237d82f0f8SDina K Nimeh /*
7247d82f0f8SDina K Nimeh * scan list of kernel ciphers looking for the selected one and if
7257d82f0f8SDina K Nimeh * it needs an iv generated using another cipher, also look for that
7267d82f0f8SDina K Nimeh * additional cipher to be used for generating the iv
7277d82f0f8SDina K Nimeh */
7287d82f0f8SDina K Nimeh count = kciphers->ml_count;
7297d82f0f8SDina K Nimeh for (i = 0; i < count && !(ciph_ok && iv_ok); i++) {
7307d82f0f8SDina K Nimeh if (!ciph_ok &&
7317d82f0f8SDina K Nimeh strcasecmp(cipher->name, kciphers->ml_list[i]) == 0)
7327d82f0f8SDina K Nimeh ciph_ok = B_TRUE;
7337d82f0f8SDina K Nimeh if (!iv_ok &&
7347d82f0f8SDina K Nimeh strcasecmp(cipher->iv_name, kciphers->ml_list[i]) == 0)
7357d82f0f8SDina K Nimeh iv_ok = B_TRUE;
7367d82f0f8SDina K Nimeh }
7377d82f0f8SDina K Nimeh free(kciphers);
7387d82f0f8SDina K Nimeh kciphers = NULL;
7397d82f0f8SDina K Nimeh
7407d82f0f8SDina K Nimeh if (!ciph_ok)
7417d82f0f8SDina K Nimeh warn(gettext("%s mechanism not supported in kernel\n"),
7427d82f0f8SDina K Nimeh cipher->name);
7437d82f0f8SDina K Nimeh if (!iv_ok)
7447d82f0f8SDina K Nimeh warn(gettext("%s mechanism not supported in kernel\n"),
7457d82f0f8SDina K Nimeh cipher->iv_name);
7467d82f0f8SDina K Nimeh
7477d82f0f8SDina K Nimeh if (ciph_ok) {
7487d82f0f8SDina K Nimeh /* Get the details about the user selected cipher */
7497d82f0f8SDina K Nimeh count = DEFAULT_MECHINFO_NUM;
7507d82f0f8SDina K Nimeh kinfo = malloc(sizeof (crypto_get_all_mechanism_info_t) +
7517d82f0f8SDina K Nimeh sizeof (crypto_mechanism_info_t) * (count - 1));
7527d82f0f8SDina K Nimeh if (kinfo == NULL) {
7537d82f0f8SDina K Nimeh warn(gettext("failed to allocate memory for "
7547d82f0f8SDina K Nimeh "kernel mechanism info"));
7557d82f0f8SDina K Nimeh goto kcc_out;
7567d82f0f8SDina K Nimeh }
7577d82f0f8SDina K Nimeh kinfo->mi_count = count;
7587d82f0f8SDina K Nimeh (void) strlcpy(kinfo->mi_mechanism_name, cipher->name,
7597d82f0f8SDina K Nimeh CRYPTO_MAX_MECH_NAME);
7607d82f0f8SDina K Nimeh
7617d82f0f8SDina K Nimeh if (ioctl(fd, CRYPTO_GET_ALL_MECHANISM_INFO, kinfo) == -1) {
7627d82f0f8SDina K Nimeh warn(gettext(
7637d82f0f8SDina K Nimeh "CRYPTO_GET_ALL_MECHANISM_INFO ioctl failed"));
7647d82f0f8SDina K Nimeh goto kcc_out;
7657d82f0f8SDina K Nimeh }
7667d82f0f8SDina K Nimeh
7677d82f0f8SDina K Nimeh if (kinfo->mi_return_value == CRYPTO_BUFFER_TOO_SMALL) {
7687d82f0f8SDina K Nimeh count = kinfo->mi_count;
7697d82f0f8SDina K Nimeh free(kinfo);
7707d82f0f8SDina K Nimeh kinfo = malloc(
7717d82f0f8SDina K Nimeh sizeof (crypto_get_all_mechanism_info_t) +
7727d82f0f8SDina K Nimeh sizeof (crypto_mechanism_info_t) * (count - 1));
7737d82f0f8SDina K Nimeh if (kinfo == NULL) {
7747d82f0f8SDina K Nimeh warn(gettext("failed to allocate memory for "
7757d82f0f8SDina K Nimeh "kernel mechanism info"));
7767d82f0f8SDina K Nimeh goto kcc_out;
7777d82f0f8SDina K Nimeh }
7787d82f0f8SDina K Nimeh kinfo->mi_count = count;
7797d82f0f8SDina K Nimeh (void) strlcpy(kinfo->mi_mechanism_name, cipher->name,
7807d82f0f8SDina K Nimeh CRYPTO_MAX_MECH_NAME);
7817d82f0f8SDina K Nimeh
7827d82f0f8SDina K Nimeh if (ioctl(fd, CRYPTO_GET_ALL_MECHANISM_INFO, kinfo) ==
7837d82f0f8SDina K Nimeh -1) {
7847d82f0f8SDina K Nimeh warn(gettext("CRYPTO_GET_ALL_MECHANISM_INFO "
7857d82f0f8SDina K Nimeh "ioctl failed"));
7867d82f0f8SDina K Nimeh goto kcc_out;
7877d82f0f8SDina K Nimeh }
7887d82f0f8SDina K Nimeh }
7897d82f0f8SDina K Nimeh
7907d82f0f8SDina K Nimeh if (kinfo->mi_return_value != CRYPTO_SUCCESS) {
7917d82f0f8SDina K Nimeh warn(gettext("CRYPTO_GET_ALL_MECHANISM_INFO ioctl "
7927d82f0f8SDina K Nimeh "return value = %d\n"), kinfo->mi_return_value);
7937d82f0f8SDina K Nimeh goto kcc_out;
7947d82f0f8SDina K Nimeh }
7957d82f0f8SDina K Nimeh
7967d82f0f8SDina K Nimeh /* Set key min and max size */
7977d82f0f8SDina K Nimeh count = kinfo->mi_count;
7987d82f0f8SDina K Nimeh i = 0;
7997d82f0f8SDina K Nimeh if (i < count) {
8007d82f0f8SDina K Nimeh keymin = kinfo->mi_list[i].mi_min_key_size;
8017d82f0f8SDina K Nimeh keymax = kinfo->mi_list[i].mi_max_key_size;
8027d82f0f8SDina K Nimeh if (kinfo->mi_list[i].mi_keysize_unit &
8037d82f0f8SDina K Nimeh CRYPTO_KEYSIZE_UNIT_IN_BITS) {
8047d82f0f8SDina K Nimeh keymin = CRYPTO_BITS2BYTES(keymin);
8057d82f0f8SDina K Nimeh keymax = CRYPTO_BITS2BYTES(keymax);
8067d82f0f8SDina K Nimeh
8077d82f0f8SDina K Nimeh }
8087d82f0f8SDina K Nimeh cipher->min_keysize = keymin;
8097d82f0f8SDina K Nimeh cipher->max_keysize = keymax;
8107d82f0f8SDina K Nimeh }
8117d82f0f8SDina K Nimeh free(kinfo);
8127d82f0f8SDina K Nimeh kinfo = NULL;
8137d82f0f8SDina K Nimeh
8147d82f0f8SDina K Nimeh if (i == count) {
8157d82f0f8SDina K Nimeh (void) close(fd);
8167d82f0f8SDina K Nimeh die(gettext(
8177d82f0f8SDina K Nimeh "failed to find usable %s kernel mechanism, "
8187d82f0f8SDina K Nimeh "use \"cryptoadm list -m\" to find available "
8197d82f0f8SDina K Nimeh "mechanisms\n"),
8207d82f0f8SDina K Nimeh cipher->name);
8217d82f0f8SDina K Nimeh }
8227d82f0f8SDina K Nimeh }
8237d82f0f8SDina K Nimeh
8247d82f0f8SDina K Nimeh /* Note: key min/max, unit size, usage for iv cipher are not checked. */
8257d82f0f8SDina K Nimeh
8267d82f0f8SDina K Nimeh return (ciph_ok && iv_ok);
8277d82f0f8SDina K Nimeh
8287d82f0f8SDina K Nimeh kcc_out:
8297d82f0f8SDina K Nimeh if (kinfo != NULL)
8307d82f0f8SDina K Nimeh free(kinfo);
8317d82f0f8SDina K Nimeh if (kciphers != NULL)
8327d82f0f8SDina K Nimeh free(kciphers);
8337d82f0f8SDina K Nimeh if (fd != -1)
8347d82f0f8SDina K Nimeh (void) close(fd);
8357d82f0f8SDina K Nimeh return (B_FALSE);
8367d82f0f8SDina K Nimeh }
8377d82f0f8SDina K Nimeh
8387d82f0f8SDina K Nimeh /*
8397d82f0f8SDina K Nimeh * Break up token spec into its components (non-destructive)
8407d82f0f8SDina K Nimeh */
8417d82f0f8SDina K Nimeh static token_spec_t *
parsetoken(char * spec)8427d82f0f8SDina K Nimeh parsetoken(char *spec)
8437d82f0f8SDina K Nimeh {
8447d82f0f8SDina K Nimeh #define FLD_NAME 0
8457d82f0f8SDina K Nimeh #define FLD_MANUF 1
8467d82f0f8SDina K Nimeh #define FLD_SERIAL 2
8477d82f0f8SDina K Nimeh #define FLD_LABEL 3
8487d82f0f8SDina K Nimeh #define NFIELDS 4
8497d82f0f8SDina K Nimeh #define nullfield(i) ((field[(i)+1] - field[(i)]) <= 1)
8507d82f0f8SDina K Nimeh #define copyfield(fld, i) \
8517d82f0f8SDina K Nimeh { \
8527d82f0f8SDina K Nimeh int n; \
8537d82f0f8SDina K Nimeh (fld) = NULL; \
8547d82f0f8SDina K Nimeh if ((n = (field[(i)+1] - field[(i)])) > 1) { \
8557d82f0f8SDina K Nimeh if (((fld) = malloc(n)) != NULL) { \
8567d82f0f8SDina K Nimeh (void) strncpy((fld), field[(i)], n); \
8577d82f0f8SDina K Nimeh ((fld))[n - 1] = '\0'; \
8587d82f0f8SDina K Nimeh } \
8597d82f0f8SDina K Nimeh } \
8607d82f0f8SDina K Nimeh }
8617d82f0f8SDina K Nimeh
8627d82f0f8SDina K Nimeh int i;
8637d82f0f8SDina K Nimeh char *field[NFIELDS + 1]; /* +1 to catch extra delimiters */
8647d82f0f8SDina K Nimeh token_spec_t *ti = NULL;
8657d82f0f8SDina K Nimeh
8667d82f0f8SDina K Nimeh if (spec == NULL)
8677d82f0f8SDina K Nimeh return (NULL);
8687d82f0f8SDina K Nimeh
8697d82f0f8SDina K Nimeh /*
8707d82f0f8SDina K Nimeh * Correct format is "[name]:[manuf]:[serial]:key". Can't use
8717d82f0f8SDina K Nimeh * strtok because it treats ":::key" and "key:::" and "key" all
8727d82f0f8SDina K Nimeh * as the same thing, and we can't have the :s compressed away.
8737d82f0f8SDina K Nimeh */
8747d82f0f8SDina K Nimeh field[0] = spec;
8757d82f0f8SDina K Nimeh for (i = 1; i < NFIELDS + 1; i++) {
8767d82f0f8SDina K Nimeh field[i] = strchr(field[i-1], ':');
8777d82f0f8SDina K Nimeh if (field[i] == NULL)
8787d82f0f8SDina K Nimeh break;
8797d82f0f8SDina K Nimeh field[i]++;
8807d82f0f8SDina K Nimeh }
8817d82f0f8SDina K Nimeh if (i < NFIELDS) /* not enough fields */
8827d82f0f8SDina K Nimeh return (NULL);
8837d82f0f8SDina K Nimeh if (field[NFIELDS] != NULL) /* too many fields */
8847d82f0f8SDina K Nimeh return (NULL);
8857d82f0f8SDina K Nimeh field[NFIELDS] = strchr(field[NFIELDS-1], '\0') + 1;
8867d82f0f8SDina K Nimeh
8877d82f0f8SDina K Nimeh /* key label can't be empty */
8887d82f0f8SDina K Nimeh if (nullfield(FLD_LABEL))
8897d82f0f8SDina K Nimeh return (NULL);
8907d82f0f8SDina K Nimeh
8917d82f0f8SDina K Nimeh ti = malloc(sizeof (token_spec_t));
8927d82f0f8SDina K Nimeh if (ti == NULL)
8937d82f0f8SDina K Nimeh return (NULL);
8947d82f0f8SDina K Nimeh
8957d82f0f8SDina K Nimeh copyfield(ti->name, FLD_NAME);
8967d82f0f8SDina K Nimeh copyfield(ti->mfr, FLD_MANUF);
8977d82f0f8SDina K Nimeh copyfield(ti->serno, FLD_SERIAL);
8987d82f0f8SDina K Nimeh copyfield(ti->key, FLD_LABEL);
8997d82f0f8SDina K Nimeh
9007d82f0f8SDina K Nimeh /*
9017d82f0f8SDina K Nimeh * If token specified and it only contains a key label, then
9027d82f0f8SDina K Nimeh * search all tokens for the key, otherwise only those with
9037d82f0f8SDina K Nimeh * matching name, mfr, and serno are used.
9047d82f0f8SDina K Nimeh */
9057d82f0f8SDina K Nimeh /*
9067d82f0f8SDina K Nimeh * That's how we'd like it to be, however, if only the key label
9077d82f0f8SDina K Nimeh * is specified, default to using softtoken. It's easier.
9087d82f0f8SDina K Nimeh */
9097d82f0f8SDina K Nimeh if (ti->name == NULL && ti->mfr == NULL && ti->serno == NULL)
9107d82f0f8SDina K Nimeh ti->name = strdup(pkcs11_default_token());
9117d82f0f8SDina K Nimeh return (ti);
9127d82f0f8SDina K Nimeh }
9137d82f0f8SDina K Nimeh
9147d82f0f8SDina K Nimeh /*
9157d82f0f8SDina K Nimeh * PBE the passphrase into a raw key
9167d82f0f8SDina K Nimeh */
9177d82f0f8SDina K Nimeh static void
getkeyfromuser(mech_alias_t * cipher,char ** raw_key,size_t * raw_key_sz,boolean_t with_confirmation)918a1b1a2a0SAndrey Sokolov getkeyfromuser(mech_alias_t *cipher, char **raw_key, size_t *raw_key_sz,
919a1b1a2a0SAndrey Sokolov boolean_t with_confirmation)
9207d82f0f8SDina K Nimeh {
9217d82f0f8SDina K Nimeh CK_SESSION_HANDLE sess;
9227d82f0f8SDina K Nimeh CK_RV rv;
9237d82f0f8SDina K Nimeh char *pass = NULL;
9247d82f0f8SDina K Nimeh size_t passlen = 0;
9257d82f0f8SDina K Nimeh void *salt = NULL; /* don't use NULL, see note on salt below */
9267d82f0f8SDina K Nimeh size_t saltlen = 0;
9277d82f0f8SDina K Nimeh CK_KEY_TYPE ktype;
9287d82f0f8SDina K Nimeh void *kvalue;
9297d82f0f8SDina K Nimeh size_t klen;
9307d82f0f8SDina K Nimeh
9317d82f0f8SDina K Nimeh /* did init_crypto find a slot that supports this cipher? */
9327d82f0f8SDina K Nimeh if (cipher->slot == (CK_SLOT_ID)-1 || cipher->max_keysize == 0) {
9337d82f0f8SDina K Nimeh rv = CKR_MECHANISM_INVALID;
9347d82f0f8SDina K Nimeh goto cleanup;
9357d82f0f8SDina K Nimeh }
9367d82f0f8SDina K Nimeh
9377d82f0f8SDina K Nimeh rv = pkcs11_mech2keytype(cipher->type, &ktype);
9387d82f0f8SDina K Nimeh if (rv != CKR_OK)
9397d82f0f8SDina K Nimeh goto cleanup;
9407d82f0f8SDina K Nimeh
9417d82f0f8SDina K Nimeh /*
9427d82f0f8SDina K Nimeh * use the passphrase to generate a PBE PKCS#5 secret key and
9437d82f0f8SDina K Nimeh * retrieve the raw key data to eventually pass it to the kernel;
9447d82f0f8SDina K Nimeh */
9457d82f0f8SDina K Nimeh rv = C_OpenSession(cipher->slot, CKF_SERIAL_SESSION, NULL, NULL, &sess);
9467d82f0f8SDina K Nimeh if (rv != CKR_OK)
9477d82f0f8SDina K Nimeh goto cleanup;
9487d82f0f8SDina K Nimeh
9497d82f0f8SDina K Nimeh /* get user passphrase with 8 byte minimum */
950a1b1a2a0SAndrey Sokolov if (pkcs11_get_pass(NULL, &pass, &passlen, MIN_PASSLEN,
951a1b1a2a0SAndrey Sokolov with_confirmation) < 0) {
9527d82f0f8SDina K Nimeh die(gettext("passphrases do not match\n"));
9537d82f0f8SDina K Nimeh }
9547d82f0f8SDina K Nimeh
9557d82f0f8SDina K Nimeh /*
9567d82f0f8SDina K Nimeh * salt should not be NULL, or else pkcs11_PasswdToKey() will
9577d82f0f8SDina K Nimeh * complain about CKR_MECHANISM_PARAM_INVALID; the following is
9587d82f0f8SDina K Nimeh * to make up for not having a salt until a proper one is used
9597d82f0f8SDina K Nimeh */
9607d82f0f8SDina K Nimeh salt = pass;
9617d82f0f8SDina K Nimeh saltlen = passlen;
9627d82f0f8SDina K Nimeh
9637d82f0f8SDina K Nimeh klen = cipher->max_keysize;
9647d82f0f8SDina K Nimeh rv = pkcs11_PasswdToKey(sess, pass, passlen, salt, saltlen, ktype,
9657d82f0f8SDina K Nimeh cipher->max_keysize, &kvalue, &klen);
9667d82f0f8SDina K Nimeh
9677d82f0f8SDina K Nimeh (void) C_CloseSession(sess);
9687d82f0f8SDina K Nimeh
9697d82f0f8SDina K Nimeh if (rv != CKR_OK) {
9707d82f0f8SDina K Nimeh goto cleanup;
9717d82f0f8SDina K Nimeh }
9727d82f0f8SDina K Nimeh
9737d82f0f8SDina K Nimeh /* assert(klen == cipher->max_keysize); */
9747d82f0f8SDina K Nimeh *raw_key_sz = klen;
9757d82f0f8SDina K Nimeh *raw_key = (char *)kvalue;
9767d82f0f8SDina K Nimeh return;
9777d82f0f8SDina K Nimeh
9787d82f0f8SDina K Nimeh cleanup:
9797d82f0f8SDina K Nimeh die(gettext("failed to generate %s key from passphrase: %s"),
9807d82f0f8SDina K Nimeh cipher->alias, pkcs11_strerror(rv));
9817d82f0f8SDina K Nimeh }
9827d82f0f8SDina K Nimeh
9837d82f0f8SDina K Nimeh /*
9847d82f0f8SDina K Nimeh * Read raw key from file; also handles ephemeral keys.
9857d82f0f8SDina K Nimeh */
9867d82f0f8SDina K Nimeh void
getkeyfromfile(const char * pathname,mech_alias_t * cipher,char ** key,size_t * ksz)9877d82f0f8SDina K Nimeh getkeyfromfile(const char *pathname, mech_alias_t *cipher, char **key,
9887d82f0f8SDina K Nimeh size_t *ksz)
9897d82f0f8SDina K Nimeh {
9907d82f0f8SDina K Nimeh int fd;
9917d82f0f8SDina K Nimeh struct stat sbuf;
9927d82f0f8SDina K Nimeh boolean_t notplain = B_FALSE;
9937d82f0f8SDina K Nimeh ssize_t cursz;
9947d82f0f8SDina K Nimeh ssize_t nread;
9957d82f0f8SDina K Nimeh
9967d82f0f8SDina K Nimeh /* ephemeral keys are just random data */
9977d82f0f8SDina K Nimeh if (pathname == NULL) {
9987d82f0f8SDina K Nimeh *ksz = cipher->max_keysize;
9997d82f0f8SDina K Nimeh *key = malloc(*ksz);
10007d82f0f8SDina K Nimeh if (*key == NULL)
10017d82f0f8SDina K Nimeh die(gettext("failed to allocate memory for"
10027d82f0f8SDina K Nimeh " ephemeral key"));
10037b79d846SDina K Nimeh if (pkcs11_get_urandom(*key, *ksz) < 0) {
10047d82f0f8SDina K Nimeh free(*key);
10057d82f0f8SDina K Nimeh die(gettext("failed to get enough random data"));
10067d82f0f8SDina K Nimeh }
10077d82f0f8SDina K Nimeh return;
10087d82f0f8SDina K Nimeh }
10097d82f0f8SDina K Nimeh
10107d82f0f8SDina K Nimeh /*
10117d82f0f8SDina K Nimeh * If the remaining section of code didn't also check for secure keyfile
10127d82f0f8SDina K Nimeh * permissions and whether the key is within cipher min and max lengths,
10137d82f0f8SDina K Nimeh * (or, if those things moved out of this block), we could have had:
10147d82f0f8SDina K Nimeh * if (pkcs11_read_data(pathname, key, ksz) < 0)
10157d82f0f8SDina K Nimeh * handle_error();
10167d82f0f8SDina K Nimeh */
10177d82f0f8SDina K Nimeh
10187d82f0f8SDina K Nimeh if ((fd = open(pathname, O_RDONLY, 0)) == -1)
10197d82f0f8SDina K Nimeh die(gettext("open of keyfile (%s) failed"), pathname);
10207d82f0f8SDina K Nimeh
10217d82f0f8SDina K Nimeh if (fstat(fd, &sbuf) == -1)
10227d82f0f8SDina K Nimeh die(gettext("fstat of keyfile (%s) failed"), pathname);
10237d82f0f8SDina K Nimeh
10247d82f0f8SDina K Nimeh if (S_ISREG(sbuf.st_mode)) {
10257d82f0f8SDina K Nimeh if ((sbuf.st_mode & (S_IWGRP | S_IWOTH)) != 0)
10267d82f0f8SDina K Nimeh die(gettext("insecure permissions on keyfile %s\n"),
10277d82f0f8SDina K Nimeh pathname);
10287d82f0f8SDina K Nimeh
10297d82f0f8SDina K Nimeh *ksz = sbuf.st_size;
10307d82f0f8SDina K Nimeh if (*ksz < cipher->min_keysize || cipher->max_keysize < *ksz) {
10317d82f0f8SDina K Nimeh warn(gettext("%s: invalid keysize: %d\n"),
10327d82f0f8SDina K Nimeh pathname, (int)*ksz);
10337d82f0f8SDina K Nimeh die(gettext("\t%d <= keysize <= %d\n"),
10347d82f0f8SDina K Nimeh cipher->min_keysize, cipher->max_keysize);
10357d82f0f8SDina K Nimeh }
10367d82f0f8SDina K Nimeh } else {
10377d82f0f8SDina K Nimeh *ksz = cipher->max_keysize;
10387d82f0f8SDina K Nimeh notplain = B_TRUE;
10397d82f0f8SDina K Nimeh }
10407d82f0f8SDina K Nimeh
10417d82f0f8SDina K Nimeh *key = malloc(*ksz);
10427d82f0f8SDina K Nimeh if (*key == NULL)
10437d82f0f8SDina K Nimeh die(gettext("failed to allocate memory for key from file"));
10447d82f0f8SDina K Nimeh
10457d82f0f8SDina K Nimeh for (cursz = 0, nread = 0; cursz < *ksz; cursz += nread) {
10467d82f0f8SDina K Nimeh nread = read(fd, *key, *ksz);
10477d82f0f8SDina K Nimeh if (nread > 0)
10487d82f0f8SDina K Nimeh continue;
10497d82f0f8SDina K Nimeh /*
10507d82f0f8SDina K Nimeh * nread == 0. If it's not a regular file we were trying to
10517d82f0f8SDina K Nimeh * get the maximum keysize of data possible for this cipher.
10527d82f0f8SDina K Nimeh * But if we've got at least the minimum keysize of data,
10537d82f0f8SDina K Nimeh * round down to the nearest keysize unit and call it good.
10547d82f0f8SDina K Nimeh * If we haven't met the minimum keysize, that's an error.
10557d82f0f8SDina K Nimeh * If it's a regular file, nread = 0 is also an error.
10567d82f0f8SDina K Nimeh */
10577d82f0f8SDina K Nimeh if (nread == 0 && notplain && cursz >= cipher->min_keysize) {
10587d82f0f8SDina K Nimeh *ksz = (cursz / cipher->min_keysize) *
10597d82f0f8SDina K Nimeh cipher->min_keysize;
10607d82f0f8SDina K Nimeh break;
10617d82f0f8SDina K Nimeh }
10627d82f0f8SDina K Nimeh die(gettext("%s: can't read all keybytes"), pathname);
10637d82f0f8SDina K Nimeh }
10647d82f0f8SDina K Nimeh (void) close(fd);
10657d82f0f8SDina K Nimeh }
10667d82f0f8SDina K Nimeh
10677d82f0f8SDina K Nimeh /*
10687d82f0f8SDina K Nimeh * Read the raw key from token, or from a file that was wrapped with a
10697d82f0f8SDina K Nimeh * key from token
10707d82f0f8SDina K Nimeh */
10717d82f0f8SDina K Nimeh void
getkeyfromtoken(CK_SESSION_HANDLE sess,token_spec_t * token,const char * keyfile,mech_alias_t * cipher,char ** raw_key,size_t * raw_key_sz)10727d82f0f8SDina K Nimeh getkeyfromtoken(CK_SESSION_HANDLE sess,
10737d82f0f8SDina K Nimeh token_spec_t *token, const char *keyfile, mech_alias_t *cipher,
10747d82f0f8SDina K Nimeh char **raw_key, size_t *raw_key_sz)
10757d82f0f8SDina K Nimeh {
10767d82f0f8SDina K Nimeh CK_RV rv = CKR_OK;
10777d82f0f8SDina K Nimeh CK_BBOOL trueval = B_TRUE;
10787d82f0f8SDina K Nimeh CK_OBJECT_CLASS kclass; /* secret key or RSA private key */
10797d82f0f8SDina K Nimeh CK_KEY_TYPE ktype; /* from selected cipher or CKK_RSA */
10807d82f0f8SDina K Nimeh CK_KEY_TYPE raw_ktype; /* from selected cipher */
10817d82f0f8SDina K Nimeh CK_ATTRIBUTE key_tmpl[] = {
10827d82f0f8SDina K Nimeh { CKA_CLASS, NULL, 0 }, /* re-used for token key and unwrap */
10837d82f0f8SDina K Nimeh { CKA_KEY_TYPE, NULL, 0 }, /* ditto */
10847d82f0f8SDina K Nimeh { CKA_LABEL, NULL, 0 },
10857d82f0f8SDina K Nimeh { CKA_TOKEN, NULL, 0 },
10867d82f0f8SDina K Nimeh { CKA_PRIVATE, NULL, 0 }
10877d82f0f8SDina K Nimeh };
10887d82f0f8SDina K Nimeh CK_ULONG attrs = sizeof (key_tmpl) / sizeof (CK_ATTRIBUTE);
10897d82f0f8SDina K Nimeh int i;
10907d82f0f8SDina K Nimeh char *pass = NULL;
10917d82f0f8SDina K Nimeh size_t passlen = 0;
10927d82f0f8SDina K Nimeh CK_OBJECT_HANDLE obj, rawobj;
10937d82f0f8SDina K Nimeh CK_ULONG num_objs = 1; /* just want to find 1 token key */
10947d82f0f8SDina K Nimeh CK_MECHANISM unwrap = { CKM_RSA_PKCS, NULL, 0 };
10957d82f0f8SDina K Nimeh char *rkey;
10967d82f0f8SDina K Nimeh size_t rksz;
10977d82f0f8SDina K Nimeh
10987d82f0f8SDina K Nimeh if (token == NULL || token->key == NULL)
10997d82f0f8SDina K Nimeh return;
11007d82f0f8SDina K Nimeh
11017d82f0f8SDina K Nimeh /* did init_crypto find a slot that supports this cipher? */
11027d82f0f8SDina K Nimeh if (cipher->slot == (CK_SLOT_ID)-1 || cipher->max_keysize == 0) {
11037d82f0f8SDina K Nimeh die(gettext("failed to find any cryptographic provider, "
11047d82f0f8SDina K Nimeh "use \"cryptoadm list -p\" to find providers: %s\n"),
11057d82f0f8SDina K Nimeh pkcs11_strerror(CKR_MECHANISM_INVALID));
11067d82f0f8SDina K Nimeh }
11077d82f0f8SDina K Nimeh
11087d82f0f8SDina K Nimeh if (pkcs11_get_pass(token->name, &pass, &passlen, 0, B_FALSE) < 0)
11097d82f0f8SDina K Nimeh die(gettext("unable to get passphrase"));
11107d82f0f8SDina K Nimeh
11117d82f0f8SDina K Nimeh /* use passphrase to login to token */
11127d82f0f8SDina K Nimeh if (pass != NULL && passlen > 0) {
11137d82f0f8SDina K Nimeh rv = C_Login(sess, CKU_USER, (CK_UTF8CHAR_PTR)pass, passlen);
11147d82f0f8SDina K Nimeh if (rv != CKR_OK) {
11157d82f0f8SDina K Nimeh die(gettext("cannot login to the token %s: %s\n"),
11167d82f0f8SDina K Nimeh token->name, pkcs11_strerror(rv));
11177d82f0f8SDina K Nimeh }
11187d82f0f8SDina K Nimeh }
11197d82f0f8SDina K Nimeh
11207d82f0f8SDina K Nimeh rv = pkcs11_mech2keytype(cipher->type, &raw_ktype);
11217d82f0f8SDina K Nimeh if (rv != CKR_OK) {
11227d82f0f8SDina K Nimeh die(gettext("failed to get key type for cipher %s: %s\n"),
11237d82f0f8SDina K Nimeh cipher->name, pkcs11_strerror(rv));
11247d82f0f8SDina K Nimeh }
11257d82f0f8SDina K Nimeh
11267d82f0f8SDina K Nimeh /*
11277d82f0f8SDina K Nimeh * If no keyfile was given, then the token key is secret key to
11287d82f0f8SDina K Nimeh * be used for encryption/decryption. Otherwise, the keyfile
11297d82f0f8SDina K Nimeh * contains a wrapped secret key, and the token is actually the
11307d82f0f8SDina K Nimeh * unwrapping RSA private key.
11317d82f0f8SDina K Nimeh */
11327d82f0f8SDina K Nimeh if (keyfile == NULL) {
11337d82f0f8SDina K Nimeh kclass = CKO_SECRET_KEY;
11347d82f0f8SDina K Nimeh ktype = raw_ktype;
11357d82f0f8SDina K Nimeh } else {
11367d82f0f8SDina K Nimeh kclass = CKO_PRIVATE_KEY;
11377d82f0f8SDina K Nimeh ktype = CKK_RSA;
11387d82f0f8SDina K Nimeh }
11397d82f0f8SDina K Nimeh
11407d82f0f8SDina K Nimeh /* Find the key in the token first */
11417d82f0f8SDina K Nimeh for (i = 0; i < attrs; i++) {
11427d82f0f8SDina K Nimeh switch (key_tmpl[i].type) {
11437d82f0f8SDina K Nimeh case CKA_CLASS:
11447d82f0f8SDina K Nimeh key_tmpl[i].pValue = &kclass;
11457d82f0f8SDina K Nimeh key_tmpl[i].ulValueLen = sizeof (kclass);
11467d82f0f8SDina K Nimeh break;
11477d82f0f8SDina K Nimeh case CKA_KEY_TYPE:
11487d82f0f8SDina K Nimeh key_tmpl[i].pValue = &ktype;
11497d82f0f8SDina K Nimeh key_tmpl[i].ulValueLen = sizeof (ktype);
11507d82f0f8SDina K Nimeh break;
11517d82f0f8SDina K Nimeh case CKA_LABEL:
11527d82f0f8SDina K Nimeh key_tmpl[i].pValue = token->key;
11537d82f0f8SDina K Nimeh key_tmpl[i].ulValueLen = strlen(token->key);
11547d82f0f8SDina K Nimeh break;
11557d82f0f8SDina K Nimeh case CKA_TOKEN:
11567d82f0f8SDina K Nimeh key_tmpl[i].pValue = &trueval;
11577d82f0f8SDina K Nimeh key_tmpl[i].ulValueLen = sizeof (trueval);
11587d82f0f8SDina K Nimeh break;
11597d82f0f8SDina K Nimeh case CKA_PRIVATE:
11607d82f0f8SDina K Nimeh key_tmpl[i].pValue = &trueval;
11617d82f0f8SDina K Nimeh key_tmpl[i].ulValueLen = sizeof (trueval);
11627d82f0f8SDina K Nimeh break;
11637d82f0f8SDina K Nimeh default:
11647d82f0f8SDina K Nimeh break;
11657d82f0f8SDina K Nimeh }
11667d82f0f8SDina K Nimeh }
11677d82f0f8SDina K Nimeh rv = C_FindObjectsInit(sess, key_tmpl, attrs);
11687d82f0f8SDina K Nimeh if (rv != CKR_OK)
11697d82f0f8SDina K Nimeh die(gettext("cannot find key %s: %s\n"), token->key,
11707d82f0f8SDina K Nimeh pkcs11_strerror(rv));
11717d82f0f8SDina K Nimeh rv = C_FindObjects(sess, &obj, 1, &num_objs);
11727d82f0f8SDina K Nimeh (void) C_FindObjectsFinal(sess);
11737d82f0f8SDina K Nimeh
11747d82f0f8SDina K Nimeh if (num_objs == 0) {
11757d82f0f8SDina K Nimeh die(gettext("cannot find key %s\n"), token->key);
11767d82f0f8SDina K Nimeh } else if (rv != CKR_OK) {
11777d82f0f8SDina K Nimeh die(gettext("cannot find key %s: %s\n"), token->key,
11787d82f0f8SDina K Nimeh pkcs11_strerror(rv));
11797d82f0f8SDina K Nimeh }
11807d82f0f8SDina K Nimeh
11817d82f0f8SDina K Nimeh /*
11827d82f0f8SDina K Nimeh * No keyfile means when token key is found, convert it to raw key,
11837d82f0f8SDina K Nimeh * and done. Otherwise still need do an unwrap to create yet another
11847d82f0f8SDina K Nimeh * obj and that needs to be converted to raw key before we're done.
11857d82f0f8SDina K Nimeh */
11867d82f0f8SDina K Nimeh if (keyfile == NULL) {
11877d82f0f8SDina K Nimeh /* obj contains raw key, extract it */
11887d82f0f8SDina K Nimeh rv = pkcs11_ObjectToKey(sess, obj, (void **)&rkey, &rksz,
11897d82f0f8SDina K Nimeh B_FALSE);
11907d82f0f8SDina K Nimeh if (rv != CKR_OK) {
11917d82f0f8SDina K Nimeh die(gettext("failed to get key value for %s"
11927d82f0f8SDina K Nimeh " from token %s, %s\n"), token->key,
11937d82f0f8SDina K Nimeh token->name, pkcs11_strerror(rv));
11947d82f0f8SDina K Nimeh }
11957d82f0f8SDina K Nimeh } else {
11967d82f0f8SDina K Nimeh getkeyfromfile(keyfile, cipher, &rkey, &rksz);
11977d82f0f8SDina K Nimeh
11987d82f0f8SDina K Nimeh /*
11997d82f0f8SDina K Nimeh * Got the wrapping RSA obj and the wrapped key from file.
12007d82f0f8SDina K Nimeh * Unwrap the key from file with RSA obj to get rawkey obj.
12017d82f0f8SDina K Nimeh */
12027d82f0f8SDina K Nimeh
12037d82f0f8SDina K Nimeh /* re-use the first two attributes of key_tmpl */
12047d82f0f8SDina K Nimeh kclass = CKO_SECRET_KEY;
12057d82f0f8SDina K Nimeh ktype = raw_ktype;
12067d82f0f8SDina K Nimeh
12077d82f0f8SDina K Nimeh rv = C_UnwrapKey(sess, &unwrap, obj, (CK_BYTE_PTR)rkey,
12087d82f0f8SDina K Nimeh rksz, key_tmpl, 2, &rawobj);
12097d82f0f8SDina K Nimeh if (rv != CKR_OK) {
12107d82f0f8SDina K Nimeh die(gettext("failed to unwrap key in keyfile %s,"
12117d82f0f8SDina K Nimeh " %s\n"), keyfile, pkcs11_strerror(rv));
12127d82f0f8SDina K Nimeh }
12137d82f0f8SDina K Nimeh /* rawobj contains raw key, extract it */
12147d82f0f8SDina K Nimeh rv = pkcs11_ObjectToKey(sess, rawobj, (void **)&rkey, &rksz,
12157d82f0f8SDina K Nimeh B_TRUE);
12167d82f0f8SDina K Nimeh if (rv != CKR_OK) {
12177d82f0f8SDina K Nimeh die(gettext("failed to get unwrapped key value for"
12187d82f0f8SDina K Nimeh " key in keyfile %s, %s\n"), keyfile,
12197d82f0f8SDina K Nimeh pkcs11_strerror(rv));
12207d82f0f8SDina K Nimeh }
12217d82f0f8SDina K Nimeh }
12227d82f0f8SDina K Nimeh
12237d82f0f8SDina K Nimeh /* validate raw key size */
12247d82f0f8SDina K Nimeh if (rksz < cipher->min_keysize || cipher->max_keysize < rksz) {
12257d82f0f8SDina K Nimeh warn(gettext("%s: invalid keysize: %d\n"), keyfile, (int)rksz);
12267d82f0f8SDina K Nimeh die(gettext("\t%d <= keysize <= %d\n"), cipher->min_keysize,
12277d82f0f8SDina K Nimeh cipher->max_keysize);
12287d82f0f8SDina K Nimeh }
12297d82f0f8SDina K Nimeh
12307d82f0f8SDina K Nimeh *raw_key_sz = rksz;
12317d82f0f8SDina K Nimeh *raw_key = (char *)rkey;
12327d82f0f8SDina K Nimeh }
12337d82f0f8SDina K Nimeh
12347d82f0f8SDina K Nimeh /*
12357d82f0f8SDina K Nimeh * Set up cipher key limits and verify PKCS#11 can be done
12367d82f0f8SDina K Nimeh * match_token_cipher is the function pointer used by
12377d82f0f8SDina K Nimeh * pkcs11_GetCriteriaSession() init_crypto.
12387d82f0f8SDina K Nimeh */
12397d82f0f8SDina K Nimeh boolean_t
match_token_cipher(CK_SLOT_ID slot_id,void * args,CK_RV * rv)12407d82f0f8SDina K Nimeh match_token_cipher(CK_SLOT_ID slot_id, void *args, CK_RV *rv)
12417d82f0f8SDina K Nimeh {
12427d82f0f8SDina K Nimeh token_spec_t *token;
12437d82f0f8SDina K Nimeh mech_alias_t *cipher;
12447d82f0f8SDina K Nimeh CK_TOKEN_INFO tokinfo;
12457d82f0f8SDina K Nimeh CK_MECHANISM_INFO mechinfo;
12467d82f0f8SDina K Nimeh boolean_t token_match;
12477d82f0f8SDina K Nimeh
12487d82f0f8SDina K Nimeh /*
12497d82f0f8SDina K Nimeh * While traversing slot list, pick up the following info per slot:
12507d82f0f8SDina K Nimeh * - if token specified, whether it matches this slot's token info
12517d82f0f8SDina K Nimeh * - if the slot supports the PKCS#5 PBKD2 cipher
12527d82f0f8SDina K Nimeh *
12537d82f0f8SDina K Nimeh * If the user said on the command line
12547d82f0f8SDina K Nimeh * -T tok:mfr:ser:lab -k keyfile
12557d82f0f8SDina K Nimeh * -c cipher -T tok:mfr:ser:lab -k keyfile
12567d82f0f8SDina K Nimeh * the given cipher or the default cipher apply to keyfile,
12577d82f0f8SDina K Nimeh * If the user said instead
12587d82f0f8SDina K Nimeh * -T tok:mfr:ser:lab
12597d82f0f8SDina K Nimeh * -c cipher -T tok:mfr:ser:lab
12607d82f0f8SDina K Nimeh * the key named "lab" may or may not agree with the given
12617d82f0f8SDina K Nimeh * cipher or the default cipher. In those cases, cipher will
12627d82f0f8SDina K Nimeh * be overridden with the actual cipher type of the key "lab".
12637d82f0f8SDina K Nimeh */
12647d82f0f8SDina K Nimeh *rv = CKR_FUNCTION_FAILED;
12657d82f0f8SDina K Nimeh
12667d82f0f8SDina K Nimeh if (args == NULL) {
12677d82f0f8SDina K Nimeh return (B_FALSE);
12687d82f0f8SDina K Nimeh }
12697d82f0f8SDina K Nimeh
12707d82f0f8SDina K Nimeh cipher = (mech_alias_t *)args;
12717d82f0f8SDina K Nimeh token = cipher->token;
12727d82f0f8SDina K Nimeh
12737d82f0f8SDina K Nimeh if (C_GetMechanismInfo(slot_id, cipher->type, &mechinfo) != CKR_OK) {
12747d82f0f8SDina K Nimeh return (B_FALSE);
12757d82f0f8SDina K Nimeh }
12767d82f0f8SDina K Nimeh
12777d82f0f8SDina K Nimeh if (token == NULL) {
12787d82f0f8SDina K Nimeh if (C_GetMechanismInfo(slot_id, CKM_PKCS5_PBKD2, &mechinfo) !=
12797d82f0f8SDina K Nimeh CKR_OK) {
12807d82f0f8SDina K Nimeh return (B_FALSE);
12817d82f0f8SDina K Nimeh }
12827d82f0f8SDina K Nimeh goto foundit;
12837d82f0f8SDina K Nimeh }
12847d82f0f8SDina K Nimeh
12857d82f0f8SDina K Nimeh /* does the token match the token spec? */
12867d82f0f8SDina K Nimeh if (token->key == NULL || (C_GetTokenInfo(slot_id, &tokinfo) != CKR_OK))
12877d82f0f8SDina K Nimeh return (B_FALSE);
12887d82f0f8SDina K Nimeh
12897d82f0f8SDina K Nimeh token_match = B_TRUE;
12907d82f0f8SDina K Nimeh
12917d82f0f8SDina K Nimeh if (token->name != NULL && (token->name)[0] != '\0' &&
12927d82f0f8SDina K Nimeh strncmp((char *)token->name, (char *)tokinfo.label,
12937d82f0f8SDina K Nimeh TOKEN_LABEL_SIZE) != 0)
12947d82f0f8SDina K Nimeh token_match = B_FALSE;
12957d82f0f8SDina K Nimeh if (token->mfr != NULL && (token->mfr)[0] != '\0' &&
12967d82f0f8SDina K Nimeh strncmp((char *)token->mfr, (char *)tokinfo.manufacturerID,
12977d82f0f8SDina K Nimeh TOKEN_MANUFACTURER_SIZE) != 0)
12987d82f0f8SDina K Nimeh token_match = B_FALSE;
12997d82f0f8SDina K Nimeh if (token->serno != NULL && (token->serno)[0] != '\0' &&
13007d82f0f8SDina K Nimeh strncmp((char *)token->serno, (char *)tokinfo.serialNumber,
13017d82f0f8SDina K Nimeh TOKEN_SERIAL_SIZE) != 0)
13027d82f0f8SDina K Nimeh token_match = B_FALSE;
13037d82f0f8SDina K Nimeh
13047d82f0f8SDina K Nimeh if (!token_match)
13057d82f0f8SDina K Nimeh return (B_FALSE);
13067d82f0f8SDina K Nimeh
13077d82f0f8SDina K Nimeh foundit:
13087d82f0f8SDina K Nimeh cipher->slot = slot_id;
13097d82f0f8SDina K Nimeh return (B_TRUE);
13107d82f0f8SDina K Nimeh }
13117d82f0f8SDina K Nimeh
13127d82f0f8SDina K Nimeh /*
13137d82f0f8SDina K Nimeh * Clean up crypto loose ends
13147d82f0f8SDina K Nimeh */
13157d82f0f8SDina K Nimeh static void
end_crypto(CK_SESSION_HANDLE sess)13167d82f0f8SDina K Nimeh end_crypto(CK_SESSION_HANDLE sess)
13177d82f0f8SDina K Nimeh {
13187d82f0f8SDina K Nimeh (void) C_CloseSession(sess);
13197d82f0f8SDina K Nimeh (void) C_Finalize(NULL);
13207d82f0f8SDina K Nimeh }
13217d82f0f8SDina K Nimeh
13227d82f0f8SDina K Nimeh /*
13237d82f0f8SDina K Nimeh * Set up crypto, opening session on slot that matches token and cipher
13247d82f0f8SDina K Nimeh */
13257d82f0f8SDina K Nimeh static void
init_crypto(token_spec_t * token,mech_alias_t * cipher,CK_SESSION_HANDLE_PTR sess)13267d82f0f8SDina K Nimeh init_crypto(token_spec_t *token, mech_alias_t *cipher,
13277d82f0f8SDina K Nimeh CK_SESSION_HANDLE_PTR sess)
13287d82f0f8SDina K Nimeh {
13297d82f0f8SDina K Nimeh CK_RV rv;
13307d82f0f8SDina K Nimeh
13317d82f0f8SDina K Nimeh cipher->token = token;
13327d82f0f8SDina K Nimeh
13337d82f0f8SDina K Nimeh /* Turn off Metaslot so that we can see actual tokens */
13347d82f0f8SDina K Nimeh if (setenv("METASLOT_ENABLED", "false", 1) < 0) {
13357d82f0f8SDina K Nimeh die(gettext("could not disable Metaslot"));
13367d82f0f8SDina K Nimeh }
13377d82f0f8SDina K Nimeh
13387d82f0f8SDina K Nimeh rv = pkcs11_GetCriteriaSession(match_token_cipher, (void *)cipher,
13397d82f0f8SDina K Nimeh sess);
13407d82f0f8SDina K Nimeh if (rv != CKR_OK) {
13417d82f0f8SDina K Nimeh end_crypto(*sess);
13427d82f0f8SDina K Nimeh if (rv == CKR_HOST_MEMORY) {
13437d82f0f8SDina K Nimeh die("malloc");
13447d82f0f8SDina K Nimeh }
13457d82f0f8SDina K Nimeh die(gettext("failed to find any cryptographic provider, "
13467d82f0f8SDina K Nimeh "use \"cryptoadm list -p\" to find providers: %s\n"),
13477d82f0f8SDina K Nimeh pkcs11_strerror(rv));
13487d82f0f8SDina K Nimeh }
13497d82f0f8SDina K Nimeh }
13507d82f0f8SDina K Nimeh
13517d82f0f8SDina K Nimeh /*
135287117650Saalok * Uncompress a file.
135387117650Saalok *
135487117650Saalok * First map the file in to establish a device
135587117650Saalok * association, then read from it. On-the-fly
135687117650Saalok * decompression will automatically uncompress
135787117650Saalok * the file if it's compressed
135887117650Saalok *
135987117650Saalok * If the file is mapped and a device association
136087117650Saalok * has been established, disallow uncompressing
136187117650Saalok * the file until it is unmapped.
136287117650Saalok */
136387117650Saalok static void
lofi_uncompress(int lfd,const char * filename)136487117650Saalok lofi_uncompress(int lfd, const char *filename)
13657c478bd9Sstevel@tonic-gate {
136687117650Saalok struct lofi_ioctl li;
136787117650Saalok char buf[MAXBSIZE];
136887117650Saalok char devicename[32];
136987117650Saalok char tmpfilename[MAXPATHLEN];
13707d82f0f8SDina K Nimeh char *x;
137187117650Saalok char *dir = NULL;
137287117650Saalok char *file = NULL;
137387117650Saalok int minor = 0;
137487117650Saalok struct stat64 statbuf;
137587117650Saalok int compfd = -1;
137687117650Saalok int uncompfd = -1;
137787117650Saalok ssize_t rbytes;
137887117650Saalok
137987117650Saalok /*
138087117650Saalok * Disallow uncompressing the file if it is
138187117650Saalok * already mapped.
138287117650Saalok */
1383789dced6SJerry Jelinek li.li_crypto_enabled = B_FALSE;
1384406fc510SToomas Soome li.li_id = 0;
138587117650Saalok (void) strlcpy(li.li_filename, filename, sizeof (li.li_filename));
138687117650Saalok if (ioctl(lfd, LOFI_GET_MINOR, &li) != -1)
138787117650Saalok die(gettext("%s must be unmapped before uncompressing"),
138887117650Saalok filename);
138987117650Saalok
139087117650Saalok /* Zero length files don't need to be uncompressed */
139187117650Saalok if (stat64(filename, &statbuf) == -1)
139287117650Saalok die(gettext("stat: %s"), filename);
139387117650Saalok if (statbuf.st_size == 0)
139487117650Saalok return;
139587117650Saalok
1396406fc510SToomas Soome minor = lofi_map_file(lfd, &li, filename);
139787117650Saalok (void) snprintf(devicename, sizeof (devicename), "/dev/%s/%d",
139887117650Saalok LOFI_BLOCK_NAME, minor);
139987117650Saalok
140087117650Saalok /* If the file isn't compressed, we just return */
140187117650Saalok if ((ioctl(lfd, LOFI_CHECK_COMPRESSED, &li) == -1) ||
1402a423e759Saalok (li.li_algorithm[0] == '\0')) {
140387117650Saalok delete_mapping(lfd, devicename, filename, B_TRUE);
1404a423e759Saalok die("%s is not compressed\n", filename);
140587117650Saalok }
140687117650Saalok
140787117650Saalok if ((compfd = open64(devicename, O_RDONLY | O_NONBLOCK)) == -1) {
140887117650Saalok delete_mapping(lfd, devicename, filename, B_TRUE);
140987117650Saalok die(gettext("open: %s"), filename);
141087117650Saalok }
141187117650Saalok /* Create a temp file in the same directory */
14127d82f0f8SDina K Nimeh x = strdup(filename);
14137d82f0f8SDina K Nimeh dir = strdup(dirname(x));
14147d82f0f8SDina K Nimeh free(x);
14157d82f0f8SDina K Nimeh x = strdup(filename);
14167d82f0f8SDina K Nimeh file = strdup(basename(x));
14177d82f0f8SDina K Nimeh free(x);
141887117650Saalok (void) snprintf(tmpfilename, sizeof (tmpfilename),
141987117650Saalok "%s/.%sXXXXXX", dir, file);
14207d82f0f8SDina K Nimeh free(dir);
14217d82f0f8SDina K Nimeh free(file);
142287117650Saalok
142387117650Saalok if ((uncompfd = mkstemp64(tmpfilename)) == -1) {
142487117650Saalok (void) close(compfd);
142587117650Saalok delete_mapping(lfd, devicename, filename, B_TRUE);
1426a423e759Saalok die("%s could not be uncompressed\n", filename);
142787117650Saalok }
142887117650Saalok
142987117650Saalok /*
143087117650Saalok * Set the mode bits and the owner of this temporary
143187117650Saalok * file to be that of the original uncompressed file
143287117650Saalok */
143387117650Saalok (void) fchmod(uncompfd, statbuf.st_mode);
143487117650Saalok
143587117650Saalok if (fchown(uncompfd, statbuf.st_uid, statbuf.st_gid) == -1) {
143687117650Saalok (void) close(compfd);
143787117650Saalok (void) close(uncompfd);
143887117650Saalok delete_mapping(lfd, devicename, filename, B_TRUE);
1439a423e759Saalok die("%s could not be uncompressed\n", filename);
144087117650Saalok }
144187117650Saalok
144287117650Saalok /* Now read from the device in MAXBSIZE-sized chunks */
144387117650Saalok for (;;) {
144487117650Saalok rbytes = read(compfd, buf, sizeof (buf));
144587117650Saalok
144687117650Saalok if (rbytes <= 0)
144787117650Saalok break;
144887117650Saalok
144987117650Saalok if (write(uncompfd, buf, rbytes) != rbytes) {
145087117650Saalok rbytes = -1;
145187117650Saalok break;
145287117650Saalok }
145387117650Saalok }
145487117650Saalok
145587117650Saalok (void) close(compfd);
145687117650Saalok (void) close(uncompfd);
145787117650Saalok
145887117650Saalok /* Delete the mapping */
145987117650Saalok delete_mapping(lfd, devicename, filename, B_TRUE);
146087117650Saalok
146187117650Saalok /*
146287117650Saalok * If an error occured while reading or writing, rbytes will
146387117650Saalok * be negative
146487117650Saalok */
146587117650Saalok if (rbytes < 0) {
146687117650Saalok (void) unlink(tmpfilename);
146787117650Saalok die(gettext("could not read from %s"), filename);
146887117650Saalok }
146987117650Saalok
147087117650Saalok /* Rename the temp file to the actual file */
147187117650Saalok if (rename(tmpfilename, filename) == -1)
147287117650Saalok (void) unlink(tmpfilename);
147387117650Saalok }
147487117650Saalok
147587117650Saalok /*
147687117650Saalok * Compress a file
147787117650Saalok */
147887117650Saalok static void
lofi_compress(int * lfd,const char * filename,int compress_index,uint32_t segsize)14799525893dSaalok lofi_compress(int *lfd, const char *filename, int compress_index,
148087117650Saalok uint32_t segsize)
148187117650Saalok {
148287117650Saalok struct lofi_ioctl lic;
148387117650Saalok lofi_compress_info_t *li;
14849525893dSaalok struct flock lock;
148587117650Saalok char tmpfilename[MAXPATHLEN];
148687117650Saalok char comp_filename[MAXPATHLEN];
148787117650Saalok char algorithm[MAXALGLEN];
14887d82f0f8SDina K Nimeh char *x;
148987117650Saalok char *dir = NULL, *file = NULL;
149087117650Saalok uchar_t *uncompressed_seg = NULL;
149187117650Saalok uchar_t *compressed_seg = NULL;
149287117650Saalok uint32_t compressed_segsize;
149387117650Saalok uint32_t len_compressed, count;
149487117650Saalok uint32_t index_entries, index_sz;
149587117650Saalok uint64_t *index = NULL;
149687117650Saalok uint64_t offset;
149787117650Saalok size_t real_segsize;
149887117650Saalok struct stat64 statbuf;
149987117650Saalok int compfd = -1, uncompfd = -1;
150087117650Saalok int tfd = -1;
150187117650Saalok ssize_t rbytes, wbytes, lastread;
150287117650Saalok int i, type;
150387117650Saalok
150487117650Saalok /*
150587117650Saalok * Disallow compressing the file if it is
150687117650Saalok * already mapped
150787117650Saalok */
1508406fc510SToomas Soome lic.li_id = 0;
150987117650Saalok (void) strlcpy(lic.li_filename, filename, sizeof (lic.li_filename));
15109525893dSaalok if (ioctl(*lfd, LOFI_GET_MINOR, &lic) != -1)
151187117650Saalok die(gettext("%s must be unmapped before compressing"),
151287117650Saalok filename);
151387117650Saalok
15149525893dSaalok /*
15159525893dSaalok * Close the control device so other operations
15169525893dSaalok * can use it
15179525893dSaalok */
15189525893dSaalok (void) close(*lfd);
15199525893dSaalok *lfd = -1;
15209525893dSaalok
152187117650Saalok li = &lofi_compress_table[compress_index];
152287117650Saalok
152387117650Saalok /*
152487117650Saalok * The size of the buffer to hold compressed data must
152587117650Saalok * be slightly larger than the compressed segment size.
152687117650Saalok *
152787117650Saalok * The compress functions use part of the buffer as
152887117650Saalok * scratch space to do calculations.
152987117650Saalok * Ref: http://www.zlib.net/manual.html#compress2
153087117650Saalok */
153187117650Saalok compressed_segsize = segsize + (segsize >> 6);
153287117650Saalok compressed_seg = (uchar_t *)malloc(compressed_segsize + SEGHDR);
153387117650Saalok uncompressed_seg = (uchar_t *)malloc(segsize);
153487117650Saalok
153587117650Saalok if (compressed_seg == NULL || uncompressed_seg == NULL)
153687117650Saalok die(gettext("No memory"));
153787117650Saalok
15389525893dSaalok if ((uncompfd = open64(filename, O_RDWR|O_LARGEFILE, 0)) == -1)
153987117650Saalok die(gettext("open: %s"), filename);
154087117650Saalok
15419525893dSaalok lock.l_type = F_WRLCK;
15429525893dSaalok lock.l_whence = SEEK_SET;
15439525893dSaalok lock.l_start = 0;
15449525893dSaalok lock.l_len = 0;
15459525893dSaalok
15469525893dSaalok /*
15479525893dSaalok * Use an advisory lock to ensure that only a
15489525893dSaalok * single lofiadm process compresses a given
15499525893dSaalok * file at any given time
15509525893dSaalok *
15519525893dSaalok * A close on the file descriptor automatically
15529525893dSaalok * closes all lock state on the file
15539525893dSaalok */
15549525893dSaalok if (fcntl(uncompfd, F_SETLKW, &lock) == -1)
15559525893dSaalok die(gettext("fcntl: %s"), filename);
15569525893dSaalok
155787117650Saalok if (fstat64(uncompfd, &statbuf) == -1) {
155887117650Saalok (void) close(uncompfd);
155987117650Saalok die(gettext("fstat: %s"), filename);
156087117650Saalok }
156187117650Saalok
156287117650Saalok /* Zero length files don't need to be compressed */
156387117650Saalok if (statbuf.st_size == 0) {
156487117650Saalok (void) close(uncompfd);
156587117650Saalok return;
156687117650Saalok }
156787117650Saalok
156887117650Saalok /*
156987117650Saalok * Create temporary files in the same directory that
157087117650Saalok * will hold the intermediate data
157187117650Saalok */
15727d82f0f8SDina K Nimeh x = strdup(filename);
15737d82f0f8SDina K Nimeh dir = strdup(dirname(x));
15747d82f0f8SDina K Nimeh free(x);
15757d82f0f8SDina K Nimeh x = strdup(filename);
15767d82f0f8SDina K Nimeh file = strdup(basename(x));
15777d82f0f8SDina K Nimeh free(x);
157887117650Saalok (void) snprintf(tmpfilename, sizeof (tmpfilename),
157987117650Saalok "%s/.%sXXXXXX", dir, file);
158087117650Saalok (void) snprintf(comp_filename, sizeof (comp_filename),
158187117650Saalok "%s/.%sXXXXXX", dir, file);
15827d82f0f8SDina K Nimeh free(dir);
15837d82f0f8SDina K Nimeh free(file);
158487117650Saalok
158587117650Saalok if ((tfd = mkstemp64(tmpfilename)) == -1)
158687117650Saalok goto cleanup;
158787117650Saalok
158887117650Saalok if ((compfd = mkstemp64(comp_filename)) == -1)
158987117650Saalok goto cleanup;
159087117650Saalok
159187117650Saalok /*
159287117650Saalok * Set the mode bits and owner of the compressed
159387117650Saalok * file to be that of the original uncompressed file
159487117650Saalok */
159587117650Saalok (void) fchmod(compfd, statbuf.st_mode);
159687117650Saalok
159787117650Saalok if (fchown(compfd, statbuf.st_uid, statbuf.st_gid) == -1)
159887117650Saalok goto cleanup;
159987117650Saalok
160087117650Saalok /*
160187117650Saalok * Calculate the number of index entries required.
160287117650Saalok * index entries are stored as an array. adding
160387117650Saalok * a '2' here accounts for the fact that the last
160487117650Saalok * segment may not be a multiple of the segment size
160587117650Saalok */
160687117650Saalok index_sz = (statbuf.st_size / segsize) + 2;
160787117650Saalok index = malloc(sizeof (*index) * index_sz);
160887117650Saalok
160987117650Saalok if (index == NULL)
161087117650Saalok goto cleanup;
161187117650Saalok
161287117650Saalok offset = 0;
161387117650Saalok lastread = segsize;
161487117650Saalok count = 0;
161587117650Saalok
161687117650Saalok /*
161787117650Saalok * Now read from the uncompressed file in 'segsize'
161887117650Saalok * sized chunks, compress what was read in and
161987117650Saalok * write it out to a temporary file
162087117650Saalok */
162187117650Saalok for (;;) {
162287117650Saalok rbytes = read(uncompfd, uncompressed_seg, segsize);
162387117650Saalok
162487117650Saalok if (rbytes <= 0)
162587117650Saalok break;
162687117650Saalok
162787117650Saalok if (lastread < segsize)
162887117650Saalok goto cleanup;
162987117650Saalok
163087117650Saalok /*
163187117650Saalok * Account for the first byte that
163287117650Saalok * indicates whether a segment is
163387117650Saalok * compressed or not
163487117650Saalok */
163587117650Saalok real_segsize = segsize - 1;
163687117650Saalok (void) li->l_compress(uncompressed_seg, rbytes,
163787117650Saalok compressed_seg + SEGHDR, &real_segsize, li->l_level);
163887117650Saalok
163987117650Saalok /*
164087117650Saalok * If the length of the compressed data is more
164187117650Saalok * than a threshold then there isn't any benefit
164287117650Saalok * to be had from compressing this segment - leave
164387117650Saalok * it uncompressed.
164487117650Saalok *
164587117650Saalok * NB. In case an error occurs during compression (above)
164687117650Saalok * the 'real_segsize' isn't changed. The logic below
164787117650Saalok * ensures that that segment is left uncompressed.
164887117650Saalok */
164987117650Saalok len_compressed = real_segsize;
16504058a205Sjrgn.keil@googlemail.com if (segsize <= COMPRESS_THRESHOLD ||
16514058a205Sjrgn.keil@googlemail.com real_segsize > (segsize - COMPRESS_THRESHOLD)) {
165287117650Saalok (void) memcpy(compressed_seg + SEGHDR, uncompressed_seg,
165387117650Saalok rbytes);
165487117650Saalok type = UNCOMPRESSED;
165587117650Saalok len_compressed = rbytes;
165687117650Saalok } else {
165787117650Saalok type = COMPRESSED;
165887117650Saalok }
165987117650Saalok
166087117650Saalok /*
166187117650Saalok * Set the first byte or the SEGHDR to
166287117650Saalok * indicate if it's compressed or not
166387117650Saalok */
166487117650Saalok *compressed_seg = type;
166587117650Saalok wbytes = write(tfd, compressed_seg, len_compressed + SEGHDR);
166687117650Saalok if (wbytes != (len_compressed + SEGHDR)) {
166787117650Saalok rbytes = -1;
166887117650Saalok break;
166987117650Saalok }
167087117650Saalok
167187117650Saalok index[count] = BE_64(offset);
167287117650Saalok offset += wbytes;
167387117650Saalok lastread = rbytes;
167487117650Saalok count++;
167587117650Saalok }
167687117650Saalok
167787117650Saalok (void) close(uncompfd);
167887117650Saalok
167987117650Saalok if (rbytes < 0)
168087117650Saalok goto cleanup;
168187117650Saalok /*
168287117650Saalok * The last index entry is a sentinel entry. It does not point to
168387117650Saalok * an actual compressed segment but helps in computing the size of
168487117650Saalok * the compressed segment. The size of each compressed segment is
168587117650Saalok * computed by subtracting the current index value from the next
168687117650Saalok * one (the compressed blocks are stored sequentially)
168787117650Saalok */
168887117650Saalok index[count++] = BE_64(offset);
168987117650Saalok
169087117650Saalok /*
169187117650Saalok * Now write the compressed data along with the
169287117650Saalok * header information to this file which will
169387117650Saalok * later be renamed to the original uncompressed
169487117650Saalok * file name
169587117650Saalok *
169687117650Saalok * The header is as follows -
169787117650Saalok *
169887117650Saalok * Signature (name of the compression algorithm)
169987117650Saalok * Compression segment size (a multiple of 512)
170087117650Saalok * Number of index entries
170187117650Saalok * Size of the last block
170287117650Saalok * The array containing the index entries
170387117650Saalok *
170487117650Saalok * the header is always stored in network byte
170587117650Saalok * order
170687117650Saalok */
170787117650Saalok (void) bzero(algorithm, sizeof (algorithm));
170887117650Saalok (void) strlcpy(algorithm, li->l_name, sizeof (algorithm));
170987117650Saalok if (write(compfd, algorithm, sizeof (algorithm))
171087117650Saalok != sizeof (algorithm))
171187117650Saalok goto cleanup;
171287117650Saalok
171387117650Saalok segsize = htonl(segsize);
171487117650Saalok if (write(compfd, &segsize, sizeof (segsize)) != sizeof (segsize))
171587117650Saalok goto cleanup;
171687117650Saalok
171787117650Saalok index_entries = htonl(count);
171887117650Saalok if (write(compfd, &index_entries, sizeof (index_entries)) !=
171987117650Saalok sizeof (index_entries))
172087117650Saalok goto cleanup;
172187117650Saalok
172287117650Saalok lastread = htonl(lastread);
172387117650Saalok if (write(compfd, &lastread, sizeof (lastread)) != sizeof (lastread))
172487117650Saalok goto cleanup;
172587117650Saalok
172687117650Saalok for (i = 0; i < count; i++) {
172787117650Saalok if (write(compfd, index + i, sizeof (*index)) !=
172887117650Saalok sizeof (*index))
172987117650Saalok goto cleanup;
173087117650Saalok }
173187117650Saalok
173287117650Saalok /* Header is written, now write the compressed data */
173387117650Saalok if (lseek(tfd, 0, SEEK_SET) != 0)
173487117650Saalok goto cleanup;
173587117650Saalok
173687117650Saalok rbytes = wbytes = 0;
173787117650Saalok
173887117650Saalok for (;;) {
173987117650Saalok rbytes = read(tfd, compressed_seg, compressed_segsize + SEGHDR);
174087117650Saalok
174187117650Saalok if (rbytes <= 0)
174287117650Saalok break;
174387117650Saalok
174487117650Saalok if (write(compfd, compressed_seg, rbytes) != rbytes)
174587117650Saalok goto cleanup;
174687117650Saalok }
174787117650Saalok
174887117650Saalok if (fstat64(compfd, &statbuf) == -1)
174987117650Saalok goto cleanup;
175087117650Saalok
175187117650Saalok /*
175287117650Saalok * Round up the compressed file size to be a multiple of
1753*bbf21555SRichard Lowe * DEV_BSIZE. lofi(4D) likes it that way.
175487117650Saalok */
175587117650Saalok if ((offset = statbuf.st_size % DEV_BSIZE) > 0) {
175687117650Saalok
175787117650Saalok offset = DEV_BSIZE - offset;
175887117650Saalok
175987117650Saalok for (i = 0; i < offset; i++)
176087117650Saalok uncompressed_seg[i] = '\0';
176187117650Saalok if (write(compfd, uncompressed_seg, offset) != offset)
176287117650Saalok goto cleanup;
176387117650Saalok }
176487117650Saalok (void) close(compfd);
176587117650Saalok (void) close(tfd);
176687117650Saalok (void) unlink(tmpfilename);
176787117650Saalok cleanup:
176887117650Saalok if (rbytes < 0) {
176987117650Saalok if (tfd != -1)
177087117650Saalok (void) unlink(tmpfilename);
177187117650Saalok if (compfd != -1)
177287117650Saalok (void) unlink(comp_filename);
177387117650Saalok die(gettext("error compressing file %s"), filename);
177487117650Saalok } else {
177587117650Saalok /* Rename the compressed file to the actual file */
177687117650Saalok if (rename(comp_filename, filename) == -1) {
177787117650Saalok (void) unlink(comp_filename);
177887117650Saalok die(gettext("error compressing file %s"), filename);
177987117650Saalok }
178087117650Saalok }
178187117650Saalok if (compressed_seg != NULL)
178287117650Saalok free(compressed_seg);
178387117650Saalok if (uncompressed_seg != NULL)
178487117650Saalok free(uncompressed_seg);
178587117650Saalok if (index != NULL)
178687117650Saalok free(index);
178787117650Saalok if (compfd != -1)
178887117650Saalok (void) close(compfd);
178987117650Saalok if (uncompfd != -1)
179087117650Saalok (void) close(uncompfd);
179187117650Saalok if (tfd != -1)
179287117650Saalok (void) close(tfd);
179387117650Saalok }
179487117650Saalok
179587117650Saalok static int
lofi_compress_select(const char * algname)179687117650Saalok lofi_compress_select(const char *algname)
179787117650Saalok {
179887117650Saalok int i;
179987117650Saalok
180087117650Saalok for (i = 0; i < LOFI_COMPRESS_FUNCTIONS; i++) {
180187117650Saalok if (strcmp(lofi_compress_table[i].l_name, algname) == 0)
180287117650Saalok return (i);
180387117650Saalok }
180487117650Saalok return (-1);
180587117650Saalok }
180687117650Saalok
180787117650Saalok static void
check_algorithm_validity(const char * algname,int * compress_index)180887117650Saalok check_algorithm_validity(const char *algname, int *compress_index)
180987117650Saalok {
181087117650Saalok *compress_index = lofi_compress_select(algname);
181187117650Saalok if (*compress_index < 0)
181287117650Saalok die(gettext("invalid algorithm name: %s\n"), algname);
181387117650Saalok }
181487117650Saalok
181587117650Saalok static void
check_file_validity(const char * filename)181687117650Saalok check_file_validity(const char *filename)
181787117650Saalok {
18187c478bd9Sstevel@tonic-gate struct stat64 buf;
181987117650Saalok int error;
18207d82f0f8SDina K Nimeh int fd;
18217c478bd9Sstevel@tonic-gate
18227c478bd9Sstevel@tonic-gate fd = open64(filename, O_RDONLY);
18237c478bd9Sstevel@tonic-gate if (fd == -1) {
18247c478bd9Sstevel@tonic-gate die(gettext("open: %s"), filename);
18257c478bd9Sstevel@tonic-gate }
18267c478bd9Sstevel@tonic-gate error = fstat64(fd, &buf);
18277c478bd9Sstevel@tonic-gate if (error == -1) {
18287c478bd9Sstevel@tonic-gate die(gettext("fstat: %s"), filename);
18297c478bd9Sstevel@tonic-gate } else if (!S_ISLOFIABLE(buf.st_mode)) {
18307c478bd9Sstevel@tonic-gate die(gettext("%s is not a regular file, "
18317c478bd9Sstevel@tonic-gate "block, or character device\n"),
18327c478bd9Sstevel@tonic-gate filename);
18337c478bd9Sstevel@tonic-gate } else if ((buf.st_size % DEV_BSIZE) != 0) {
1834f9153c6bSDina K Nimeh die(gettext("size of %s is not a multiple of %d\n"),
18357c478bd9Sstevel@tonic-gate filename, DEV_BSIZE);
18367c478bd9Sstevel@tonic-gate }
18377c478bd9Sstevel@tonic-gate (void) close(fd);
183887117650Saalok
183987117650Saalok if (name_to_minor(filename) != 0) {
1840f9153c6bSDina K Nimeh die(gettext("cannot use %s on itself\n"), LOFI_DRIVER_NAME);
18417c478bd9Sstevel@tonic-gate }
184287117650Saalok }
184387117650Saalok
1844a1b1a2a0SAndrey Sokolov static boolean_t
check_file_is_encrypted(const char * filename)1845a1b1a2a0SAndrey Sokolov check_file_is_encrypted(const char *filename)
1846a1b1a2a0SAndrey Sokolov {
1847a1b1a2a0SAndrey Sokolov int fd;
1848a1b1a2a0SAndrey Sokolov char buf[sizeof (lofi_crypto_magic)];
1849a1b1a2a0SAndrey Sokolov int got;
1850a1b1a2a0SAndrey Sokolov int rest = sizeof (lofi_crypto_magic);
1851a1b1a2a0SAndrey Sokolov
1852a1b1a2a0SAndrey Sokolov fd = open64(filename, O_RDONLY);
1853a1b1a2a0SAndrey Sokolov if (fd == -1)
1854a1b1a2a0SAndrey Sokolov die(gettext("failed to open: %s"), filename);
1855a1b1a2a0SAndrey Sokolov
1856a1b1a2a0SAndrey Sokolov if (lseek(fd, CRYOFF, SEEK_SET) != CRYOFF)
1857a1b1a2a0SAndrey Sokolov die(gettext("failed to seek to offset 0x%lx in file %s"),
1858a1b1a2a0SAndrey Sokolov CRYOFF, filename);
1859a1b1a2a0SAndrey Sokolov
1860a1b1a2a0SAndrey Sokolov do {
1861a1b1a2a0SAndrey Sokolov got = read(fd, buf + sizeof (lofi_crypto_magic) - rest, rest);
1862a1b1a2a0SAndrey Sokolov if ((got == 0) || ((got == -1) && (errno != EINTR)))
1863a1b1a2a0SAndrey Sokolov die(gettext("failed to read crypto header"
1864a1b1a2a0SAndrey Sokolov " at offset 0x%lx in file %s"), CRYOFF, filename);
1865a1b1a2a0SAndrey Sokolov
1866a1b1a2a0SAndrey Sokolov if (got > 0)
1867a1b1a2a0SAndrey Sokolov rest -= got;
1868a1b1a2a0SAndrey Sokolov } while (rest > 0);
1869a1b1a2a0SAndrey Sokolov
1870a1b1a2a0SAndrey Sokolov while (close(fd) == -1) {
1871a1b1a2a0SAndrey Sokolov if (errno != EINTR)
1872a1b1a2a0SAndrey Sokolov die(gettext("failed to close file %s"), filename);
1873a1b1a2a0SAndrey Sokolov }
1874a1b1a2a0SAndrey Sokolov
1875a1b1a2a0SAndrey Sokolov return (strncmp(buf, lofi_crypto_magic,
1876a1b1a2a0SAndrey Sokolov sizeof (lofi_crypto_magic)) == 0);
1877a1b1a2a0SAndrey Sokolov }
1878a1b1a2a0SAndrey Sokolov
187987117650Saalok static uint32_t
convert_to_num(const char * str)188087117650Saalok convert_to_num(const char *str)
188187117650Saalok {
188287117650Saalok int len;
188387117650Saalok uint32_t segsize, mult = 1;
188487117650Saalok
188587117650Saalok len = strlen(str);
188687117650Saalok if (len && isalpha(str[len - 1])) {
188787117650Saalok switch (str[len - 1]) {
188887117650Saalok case 'k':
188987117650Saalok case 'K':
189087117650Saalok mult = KILOBYTE;
189187117650Saalok break;
189287117650Saalok case 'b':
189387117650Saalok case 'B':
189487117650Saalok mult = BLOCK_SIZE;
189587117650Saalok break;
189687117650Saalok case 'm':
189787117650Saalok case 'M':
189887117650Saalok mult = MEGABYTE;
189987117650Saalok break;
190087117650Saalok case 'g':
190187117650Saalok case 'G':
190287117650Saalok mult = GIGABYTE;
190387117650Saalok break;
190487117650Saalok default:
190587117650Saalok die(gettext("invalid segment size %s\n"), str);
190687117650Saalok }
190787117650Saalok }
190887117650Saalok
190987117650Saalok segsize = atol(str);
191087117650Saalok segsize *= mult;
191187117650Saalok
191287117650Saalok return (segsize);
191387117650Saalok }
191487117650Saalok
191587117650Saalok int
main(int argc,char * argv[])191687117650Saalok main(int argc, char *argv[])
191787117650Saalok {
191887117650Saalok int lfd;
191987117650Saalok int c;
192087117650Saalok const char *devicename = NULL;
192187117650Saalok const char *filename = NULL;
192287117650Saalok const char *algname = COMPRESS_ALGORITHM;
192387117650Saalok int openflag;
192487117650Saalok int minor;
192587117650Saalok int compress_index;
192687117650Saalok uint32_t segsize = SEGSIZE;
192787117650Saalok static char *lofictl = "/dev/" LOFI_CTL_NAME;
192887117650Saalok boolean_t force = B_FALSE;
19297d82f0f8SDina K Nimeh const char *pname;
19307d82f0f8SDina K Nimeh boolean_t errflag = B_FALSE;
19317d82f0f8SDina K Nimeh boolean_t addflag = B_FALSE;
1932406fc510SToomas Soome boolean_t labelflag = B_FALSE;
1933cd69fabeSAlexander Eremin boolean_t rdflag = B_FALSE;
19347d82f0f8SDina K Nimeh boolean_t deleteflag = B_FALSE;
19357d82f0f8SDina K Nimeh boolean_t ephflag = B_FALSE;
19367d82f0f8SDina K Nimeh boolean_t compressflag = B_FALSE;
19377d82f0f8SDina K Nimeh boolean_t uncompressflag = B_FALSE;
19387d82f0f8SDina K Nimeh /* the next two work together for -c, -k, -T, -e options only */
19397d82f0f8SDina K Nimeh boolean_t need_crypto = B_FALSE; /* if any -c, -k, -T, -e */
19407d82f0f8SDina K Nimeh boolean_t cipher_only = B_TRUE; /* if -c only */
19417d82f0f8SDina K Nimeh const char *keyfile = NULL;
19427d82f0f8SDina K Nimeh mech_alias_t *cipher = NULL;
19437d82f0f8SDina K Nimeh token_spec_t *token = NULL;
19447d82f0f8SDina K Nimeh char *rkey = NULL;
19457d82f0f8SDina K Nimeh size_t rksz = 0;
1946f9153c6bSDina K Nimeh char realfilename[MAXPATHLEN];
194787117650Saalok
194887117650Saalok pname = getpname(argv[0]);
194987117650Saalok
195087117650Saalok (void) setlocale(LC_ALL, "");
195187117650Saalok (void) textdomain(TEXT_DOMAIN);
195287117650Saalok
19536aa98485SToomas Soome while ((c = getopt(argc, argv, "a:c:Cd:efk:lrs:T:U")) != EOF) {
195487117650Saalok switch (c) {
195587117650Saalok case 'a':
19567d82f0f8SDina K Nimeh addflag = B_TRUE;
1957f9153c6bSDina K Nimeh if ((filename = realpath(optarg, realfilename)) == NULL)
1958f9153c6bSDina K Nimeh die("%s", optarg);
19597c478bd9Sstevel@tonic-gate if (((argc - optind) > 0) && (*argv[optind] != '-')) {
19607c478bd9Sstevel@tonic-gate /* optional device */
19617c478bd9Sstevel@tonic-gate devicename = argv[optind];
19627c478bd9Sstevel@tonic-gate optind++;
19637c478bd9Sstevel@tonic-gate }
19647c478bd9Sstevel@tonic-gate break;
196587117650Saalok case 'C':
19667d82f0f8SDina K Nimeh compressflag = B_TRUE;
19677d82f0f8SDina K Nimeh if (((argc - optind) > 1) && (*argv[optind] != '-')) {
19687d82f0f8SDina K Nimeh /* optional algorithm */
19697d82f0f8SDina K Nimeh algname = argv[optind];
197087117650Saalok optind++;
197187117650Saalok }
197287117650Saalok check_algorithm_validity(algname, &compress_index);
197387117650Saalok break;
19747d82f0f8SDina K Nimeh case 'c':
19757d82f0f8SDina K Nimeh /* is the chosen cipher allowed? */
19767d82f0f8SDina K Nimeh if ((cipher = ciph2mech(optarg)) == NULL) {
19777d82f0f8SDina K Nimeh errflag = B_TRUE;
19787d82f0f8SDina K Nimeh warn(gettext("cipher %s not allowed\n"),
19797d82f0f8SDina K Nimeh optarg);
19807d82f0f8SDina K Nimeh }
19817d82f0f8SDina K Nimeh need_crypto = B_TRUE;
19827d82f0f8SDina K Nimeh /* cipher_only is already set */
19837d82f0f8SDina K Nimeh break;
19847c478bd9Sstevel@tonic-gate case 'd':
19857d82f0f8SDina K Nimeh deleteflag = B_TRUE;
19867c478bd9Sstevel@tonic-gate minor = name_to_minor(optarg);
19877c478bd9Sstevel@tonic-gate if (minor != 0)
19887c478bd9Sstevel@tonic-gate devicename = optarg;
1989f9153c6bSDina K Nimeh else {
1990f9153c6bSDina K Nimeh if ((filename = realpath(optarg,
1991f9153c6bSDina K Nimeh realfilename)) == NULL)
1992f9153c6bSDina K Nimeh die("%s", optarg);
1993f9153c6bSDina K Nimeh }
19947c478bd9Sstevel@tonic-gate break;
19957d82f0f8SDina K Nimeh case 'e':
19967d82f0f8SDina K Nimeh ephflag = B_TRUE;
19977d82f0f8SDina K Nimeh need_crypto = B_TRUE;
19987d82f0f8SDina K Nimeh cipher_only = B_FALSE; /* need to unset cipher_only */
19997d82f0f8SDina K Nimeh break;
20003d7072f8Seschrock case 'f':
20013d7072f8Seschrock force = B_TRUE;
20023d7072f8Seschrock break;
20037d82f0f8SDina K Nimeh case 'k':
20047d82f0f8SDina K Nimeh keyfile = optarg;
20057d82f0f8SDina K Nimeh need_crypto = B_TRUE;
20067d82f0f8SDina K Nimeh cipher_only = B_FALSE; /* need to unset cipher_only */
20077d82f0f8SDina K Nimeh break;
2008406fc510SToomas Soome case 'l':
2009406fc510SToomas Soome labelflag = B_TRUE;
2010406fc510SToomas Soome break;
2011cd69fabeSAlexander Eremin case 'r':
2012cd69fabeSAlexander Eremin rdflag = B_TRUE;
2013cd69fabeSAlexander Eremin break;
201487117650Saalok case 's':
201587117650Saalok segsize = convert_to_num(optarg);
20164058a205Sjrgn.keil@googlemail.com if (segsize < DEV_BSIZE || !ISP2(segsize))
201787117650Saalok die(gettext("segment size %s is invalid "
201887117650Saalok "or not a multiple of minimum block "
201987117650Saalok "size %ld\n"), optarg, DEV_BSIZE);
20207d82f0f8SDina K Nimeh break;
20217d82f0f8SDina K Nimeh case 'T':
20227d82f0f8SDina K Nimeh if ((token = parsetoken(optarg)) == NULL) {
20237d82f0f8SDina K Nimeh errflag = B_TRUE;
20247d82f0f8SDina K Nimeh warn(
20257d82f0f8SDina K Nimeh gettext("invalid token key specifier %s\n"),
20267d82f0f8SDina K Nimeh optarg);
20277d82f0f8SDina K Nimeh }
20287d82f0f8SDina K Nimeh need_crypto = B_TRUE;
20297d82f0f8SDina K Nimeh cipher_only = B_FALSE; /* need to unset cipher_only */
203087117650Saalok break;
203187117650Saalok case 'U':
20327d82f0f8SDina K Nimeh uncompressflag = B_TRUE;
203387117650Saalok break;
20347c478bd9Sstevel@tonic-gate case '?':
20357c478bd9Sstevel@tonic-gate default:
20367d82f0f8SDina K Nimeh errflag = B_TRUE;
20377c478bd9Sstevel@tonic-gate break;
20387c478bd9Sstevel@tonic-gate }
20397c478bd9Sstevel@tonic-gate }
20407d82f0f8SDina K Nimeh
20417d82f0f8SDina K Nimeh /* Check for mutually exclusive combinations of options */
204287117650Saalok if (errflag ||
204387117650Saalok (addflag && deleteflag) ||
2044406fc510SToomas Soome (labelflag && !addflag) ||
2045cd69fabeSAlexander Eremin (rdflag && !addflag) ||
20467d82f0f8SDina K Nimeh (!addflag && need_crypto) ||
2047406fc510SToomas Soome (need_crypto && labelflag) ||
2048406fc510SToomas Soome ((compressflag || uncompressflag) &&
2049406fc510SToomas Soome (labelflag || addflag || deleteflag)))
20507d82f0f8SDina K Nimeh usage(pname);
20517d82f0f8SDina K Nimeh
20527d82f0f8SDina K Nimeh /* ephemeral key, and key from either file or token are incompatible */
20537d82f0f8SDina K Nimeh if (ephflag && (keyfile != NULL || token != NULL)) {
20547d82f0f8SDina K Nimeh die(gettext("ephemeral key cannot be used with keyfile"
20557d82f0f8SDina K Nimeh " or token key\n"));
20567d82f0f8SDina K Nimeh }
20577d82f0f8SDina K Nimeh
20587d82f0f8SDina K Nimeh /*
20597d82f0f8SDina K Nimeh * "-c" but no "-k", "-T", "-e", or "-T -k" means derive key from
20607d82f0f8SDina K Nimeh * command line passphrase
20617d82f0f8SDina K Nimeh */
20627c478bd9Sstevel@tonic-gate
20637c478bd9Sstevel@tonic-gate switch (argc - optind) {
20647c478bd9Sstevel@tonic-gate case 0: /* no more args */
20657d82f0f8SDina K Nimeh if (compressflag || uncompressflag) /* needs filename */
20667d82f0f8SDina K Nimeh usage(pname);
20677c478bd9Sstevel@tonic-gate break;
20687d82f0f8SDina K Nimeh case 1:
20697c478bd9Sstevel@tonic-gate if (addflag || deleteflag)
20707d82f0f8SDina K Nimeh usage(pname);
20717d82f0f8SDina K Nimeh /* one arg means compress/uncompress the file ... */
20727d82f0f8SDina K Nimeh if (compressflag || uncompressflag) {
20737d82f0f8SDina K Nimeh if ((filename = realpath(argv[optind],
20747d82f0f8SDina K Nimeh realfilename)) == NULL)
20757d82f0f8SDina K Nimeh die("%s", argv[optind]);
20767d82f0f8SDina K Nimeh /* ... or without options means print the association */
20777d82f0f8SDina K Nimeh } else {
20787c478bd9Sstevel@tonic-gate minor = name_to_minor(argv[optind]);
20797c478bd9Sstevel@tonic-gate if (minor != 0)
20807c478bd9Sstevel@tonic-gate devicename = argv[optind];
2081f9153c6bSDina K Nimeh else {
2082f9153c6bSDina K Nimeh if ((filename = realpath(argv[optind],
2083f9153c6bSDina K Nimeh realfilename)) == NULL)
2084f9153c6bSDina K Nimeh die("%s", argv[optind]);
2085f9153c6bSDina K Nimeh }
20867d82f0f8SDina K Nimeh }
20877c478bd9Sstevel@tonic-gate break;
20887c478bd9Sstevel@tonic-gate default:
20897d82f0f8SDina K Nimeh usage(pname);
20907c478bd9Sstevel@tonic-gate break;
20917c478bd9Sstevel@tonic-gate }
20927c478bd9Sstevel@tonic-gate
20937d82f0f8SDina K Nimeh if (addflag || compressflag || uncompressflag)
20947d82f0f8SDina K Nimeh check_file_validity(filename);
20957d82f0f8SDina K Nimeh
20967c478bd9Sstevel@tonic-gate if (filename && !valid_abspath(filename))
20977c478bd9Sstevel@tonic-gate exit(E_ERROR);
20987c478bd9Sstevel@tonic-gate
20997c478bd9Sstevel@tonic-gate /*
21007c478bd9Sstevel@tonic-gate * Here, we know the arguments are correct, the filename is an
21017c478bd9Sstevel@tonic-gate * absolute path, it exists and is a regular file. We don't yet
21027c478bd9Sstevel@tonic-gate * know that the device name is ok or not.
21037c478bd9Sstevel@tonic-gate */
21047d82f0f8SDina K Nimeh
21057c478bd9Sstevel@tonic-gate openflag = O_EXCL;
210687117650Saalok if (addflag || deleteflag || compressflag || uncompressflag)
21077c478bd9Sstevel@tonic-gate openflag |= O_RDWR;
21087c478bd9Sstevel@tonic-gate else
21097c478bd9Sstevel@tonic-gate openflag |= O_RDONLY;
21107c478bd9Sstevel@tonic-gate lfd = open(lofictl, openflag);
21117c478bd9Sstevel@tonic-gate if (lfd == -1) {
21127c478bd9Sstevel@tonic-gate if ((errno == EPERM) || (errno == EACCES)) {
2113f9153c6bSDina K Nimeh die(gettext("you do not have permission to perform "
2114f9153c6bSDina K Nimeh "that operation.\n"));
21157c478bd9Sstevel@tonic-gate } else {
2116f9153c6bSDina K Nimeh die(gettext("open: %s"), lofictl);
21177c478bd9Sstevel@tonic-gate }
21187c478bd9Sstevel@tonic-gate /*NOTREACHED*/
21197c478bd9Sstevel@tonic-gate }
21207d82f0f8SDina K Nimeh
21217d82f0f8SDina K Nimeh /*
21227d82f0f8SDina K Nimeh * No passphrase is needed for ephemeral key, or when key is
21237d82f0f8SDina K Nimeh * in a file and not wrapped by another key from a token.
21247d82f0f8SDina K Nimeh * However, a passphrase is needed in these cases:
21257d82f0f8SDina K Nimeh * 1. cipher with no ephemeral key, key file, or token,
21267d82f0f8SDina K Nimeh * in which case the passphrase is used to build the key
21277d82f0f8SDina K Nimeh * 2. token with an optional cipher or optional key file,
21287d82f0f8SDina K Nimeh * in which case the passphrase unlocks the token
21297d82f0f8SDina K Nimeh * If only the cipher is specified, reconfirm the passphrase
21307d82f0f8SDina K Nimeh * to ensure the user hasn't mis-entered it. Otherwise, the
21317d82f0f8SDina K Nimeh * token will enforce the token passphrase.
21327d82f0f8SDina K Nimeh */
21337d82f0f8SDina K Nimeh if (need_crypto) {
21347d82f0f8SDina K Nimeh CK_SESSION_HANDLE sess;
21357d82f0f8SDina K Nimeh
21367d82f0f8SDina K Nimeh /* pick a cipher if none specified */
21377d82f0f8SDina K Nimeh if (cipher == NULL)
21387d82f0f8SDina K Nimeh cipher = DEFAULT_CIPHER;
21397d82f0f8SDina K Nimeh
21407d82f0f8SDina K Nimeh if (!kernel_cipher_check(cipher))
21417d82f0f8SDina K Nimeh die(gettext(
21427d82f0f8SDina K Nimeh "use \"cryptoadm list -m\" to find available "
21437d82f0f8SDina K Nimeh "mechanisms\n"));
21447d82f0f8SDina K Nimeh
21457d82f0f8SDina K Nimeh init_crypto(token, cipher, &sess);
21467d82f0f8SDina K Nimeh
21477d82f0f8SDina K Nimeh if (cipher_only) {
2148a1b1a2a0SAndrey Sokolov getkeyfromuser(cipher, &rkey, &rksz,
2149a1b1a2a0SAndrey Sokolov !check_file_is_encrypted(filename));
21507d82f0f8SDina K Nimeh } else if (token != NULL) {
21517d82f0f8SDina K Nimeh getkeyfromtoken(sess, token, keyfile, cipher,
21527d82f0f8SDina K Nimeh &rkey, &rksz);
21537d82f0f8SDina K Nimeh } else {
21547d82f0f8SDina K Nimeh /* this also handles ephemeral keys */
21557d82f0f8SDina K Nimeh getkeyfromfile(keyfile, cipher, &rkey, &rksz);
21567d82f0f8SDina K Nimeh }
21577d82f0f8SDina K Nimeh
21587d82f0f8SDina K Nimeh end_crypto(sess);
21597d82f0f8SDina K Nimeh }
21607d82f0f8SDina K Nimeh
21617d82f0f8SDina K Nimeh /*
21627d82f0f8SDina K Nimeh * Now to the real work.
21637d82f0f8SDina K Nimeh */
21647c478bd9Sstevel@tonic-gate if (addflag)
2165cd69fabeSAlexander Eremin add_mapping(lfd, devicename, filename, cipher, rkey, rksz,
2166406fc510SToomas Soome rdflag, labelflag);
216787117650Saalok else if (compressflag)
21689525893dSaalok lofi_compress(&lfd, filename, compress_index, segsize);
216987117650Saalok else if (uncompressflag)
217087117650Saalok lofi_uncompress(lfd, filename);
21717c478bd9Sstevel@tonic-gate else if (deleteflag)
21723d7072f8Seschrock delete_mapping(lfd, devicename, filename, force);
21737c478bd9Sstevel@tonic-gate else if (filename || devicename)
21747c478bd9Sstevel@tonic-gate print_one_mapping(lfd, devicename, filename);
21757c478bd9Sstevel@tonic-gate else
21767c478bd9Sstevel@tonic-gate print_mappings(lfd);
2177579df0adSaalok
21789525893dSaalok if (lfd != -1)
21797c478bd9Sstevel@tonic-gate (void) close(lfd);
2180579df0adSaalok closelib();
21817c478bd9Sstevel@tonic-gate return (E_SUCCESS);
21827c478bd9Sstevel@tonic-gate }
2183