1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1988 AT&T */
28 /* All Rights Reserved */
29
30 #pragma ident "%Z%%M% %I% %E% SMI"
31
32 #pragma weak _run_setkey = run_setkey
33 #pragma weak _run_crypt = run_crypt
34 #pragma weak _crypt_close = crypt_close
35 #pragma weak _makekey = makekey
36
37 #include <stdio.h>
38 #include <signal.h>
39 #include <fcntl.h>
40 #include <errno.h>
41 #include <thread.h>
42 #include <sys/types.h>
43 #include <unistd.h>
44 #include <strings.h>
45 #include <crypt.h>
46 #include "des_soft.h"
47 #include "lib_gen.h"
48
49 #define READER 0
50 #define WRITER 1
51 #define KSIZE 8
52
53 /* Global Variables */
54 static char key[KSIZE+1];
55 struct header {
56 long offset;
57 unsigned int count;
58 };
59
60 static mutex_t lock = DEFAULTMUTEX;
61
62 static int cryptopen();
63 static int writekey();
64
65 void _exit();
66
67 int
run_setkey(int p[2],const char * keyparam)68 run_setkey(int p[2], const char *keyparam)
69 {
70 (void) mutex_lock(&lock);
71 if (cryptopen(p) == -1) {
72 (void) mutex_unlock(&lock);
73 return (-1);
74 }
75 (void) strncpy(key, keyparam, KSIZE);
76 if (*key == 0) {
77 (void) crypt_close_nolock(p);
78 (void) mutex_unlock(&lock);
79 return (0);
80 }
81 if (writekey(p, key) == -1) {
82 (void) mutex_unlock(&lock);
83 return (-1);
84 }
85 (void) mutex_unlock(&lock);
86 return (1);
87 }
88
89 static char cmd[] = "exec /usr/bin/crypt -p 2>/dev/null";
90 static int
cryptopen(int p[2])91 cryptopen(int p[2])
92 {
93 char c;
94
95 if (__p2open(cmd, p) < 0)
96 return (-1);
97 if (read(p[WRITER], &c, 1) != 1) { /* check that crypt is working on */
98 /* other end */
99 (void) crypt_close(p); /* remove defunct process */
100 return (-1);
101 }
102 return (1);
103 }
104
105 static int
writekey(int p[2],char * keyarg)106 writekey(int p[2], char *keyarg)
107 {
108 void (*pstat) ();
109 pstat = signal(SIGPIPE, SIG_IGN); /* don't want pipe errors to cause */
110 /* death */
111 if (write(p[READER], keyarg, KSIZE) != KSIZE) {
112 (void) crypt_close(p); /* remove defunct process */
113 (void) signal(SIGPIPE, pstat);
114 return (-1);
115 }
116 (void) signal(SIGPIPE, pstat);
117 return (1);
118 }
119
120
121 int
run_crypt(long offset,char * buffer,unsigned int count,int p[2])122 run_crypt(long offset, char *buffer, unsigned int count, int p[2])
123 {
124 struct header header;
125 void (*pstat) ();
126
127 (void) mutex_lock(&lock);
128 header.count = count;
129 header.offset = offset;
130 pstat = signal(SIGPIPE, SIG_IGN);
131 if (write(p[READER], (char *)&header, sizeof (header))
132 != sizeof (header)) {
133 (void) crypt_close_nolock(p);
134 (void) signal(SIGPIPE, pstat);
135 (void) mutex_unlock(&lock);
136 return (-1);
137 }
138 if (write(p[READER], buffer, count) < count) {
139 (void) crypt_close_nolock(p);
140 (void) signal(SIGPIPE, pstat);
141 (void) mutex_unlock(&lock);
142 return (-1);
143 }
144 if (read(p[WRITER], buffer, count) < count) {
145 (void) crypt_close_nolock(p);
146 (void) signal(SIGPIPE, pstat);
147 (void) mutex_unlock(&lock);
148 return (-1);
149 }
150 (void) signal(SIGPIPE, pstat);
151 (void) mutex_unlock(&lock);
152 return (0);
153 }
154
155 int
makekey(int b[2])156 makekey(int b[2])
157 {
158 int i;
159 long gorp;
160 char tempbuf[KSIZE], *a, *temp;
161
162 (void) mutex_lock(&lock);
163 a = key;
164 temp = tempbuf;
165 for (i = 0; i < KSIZE; i++)
166 temp[i] = *a++;
167 gorp = getuid() + getgid();
168
169 for (i = 0; i < 4; i++)
170 temp[i] ^= (char)((gorp>>(8*i))&0377);
171
172 if (cryptopen(b) == -1) {
173 (void) mutex_unlock(&lock);
174 return (-1);
175 }
176 if (writekey(b, temp) == -1) {
177 (void) mutex_unlock(&lock);
178 return (-1);
179 }
180 (void) mutex_unlock(&lock);
181 return (0);
182 }
183
184 int
crypt_close_nolock(int p[2])185 crypt_close_nolock(int p[2])
186 {
187
188 if (p[0] == 0 && p[1] == 0 || p[0] < 0 || p[1] < 0) {
189 return (-1);
190 }
191
192 return (__p2close(p, NULL, SIGKILL));
193 }
194
195 int
crypt_close(int p[2])196 crypt_close(int p[2])
197 {
198 (void) mutex_lock(&lock);
199 (void) crypt_close_nolock(p);
200 (void) mutex_unlock(&lock);
201 return (0);
202 }
203