/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to mandos-keygen

  • Committer: Björn Påhlsson
  • Date: 2008-07-20 02:52:20 UTC
  • Revision ID: belorn@braxen-20080720025220-r5u0388uy9iu23h6
Added following support:
Pluginbased client handler
rewritten Mandos client
       Avahi instead of udp server discovery
       openpgp encrypted key support
Passprompt stand alone application for direct console input
Added logging for Mandos server

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-keygen
1
 
#!/bin/sh -e
2
 
# 
3
 
# Mandos key generator - create a new OpenPGP key for a Mandos client
4
 
# 
5
 
# Copyright © 2008-2013 Teddy Hogeborn
6
 
# Copyright © 2008-2013 Björn Påhlsson
7
 
# 
8
 
# This program is free software: you can redistribute it and/or modify
9
 
# it under the terms of the GNU General Public License as published by
10
 
# the Free Software Foundation, either version 3 of the License, or
11
 
# (at your option) any later version.
12
 
#
13
 
#     This program is distributed in the hope that it will be useful,
14
 
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
 
#     GNU General Public License for more details.
17
 
# 
18
 
# You should have received a copy of the GNU General Public License
19
 
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
20
 
# 
21
 
# Contact the authors at <mandos@recompile.se>.
22
 
# 
23
 
 
24
 
VERSION="1.6.4"
25
 
 
26
 
KEYDIR="/etc/keys/mandos"
27
 
KEYTYPE=RSA
28
 
KEYLENGTH=4096
29
 
SUBKEYTYPE=RSA
30
 
SUBKEYLENGTH=4096
31
 
KEYNAME="`hostname --fqdn 2>/dev/null || hostname`"
32
 
KEYEMAIL=""
33
 
KEYCOMMENT=""
34
 
KEYEXPIRE=0
35
 
FORCE=no
36
 
KEYCOMMENT_ORIG="$KEYCOMMENT"
37
 
mode=keygen
38
 
 
39
 
if [ ! -d "$KEYDIR" ]; then
40
 
    KEYDIR="/etc/mandos/keys"
41
 
fi
42
 
 
43
 
# Parse options
44
 
TEMP=`getopt --options vhpF:d:t:l:s:L:n:e:c:x:f \
45
 
    --longoptions version,help,password,passfile:,dir:,type:,length:,subtype:,sublength:,name:,email:,comment:,expire:,force \
46
 
    --name "$0" -- "$@"`
47
 
 
48
 
help(){
49
 
basename="`basename $0`"
50
 
cat <<EOF
51
 
Usage: $basename [ -v | --version ]
52
 
       $basename [ -h | --help ]
53
 
   Key creation:
54
 
       $basename [ OPTIONS ]
55
 
   Encrypted password creation:
56
 
       $basename { -p | --password } [ --name NAME ] [ --dir DIR]
57
 
       $basename { -F | --passfile } FILE [ --name NAME ] [ --dir DIR]
58
 
 
59
 
Key creation options:
60
 
  -v, --version         Show program's version number and exit
61
 
  -h, --help            Show this help message and exit
62
 
  -d DIR, --dir DIR     Target directory for key files
63
 
  -t TYPE, --type TYPE  Key type.  Default is RSA.
64
 
  -l BITS, --length BITS
65
 
                        Key length in bits.  Default is 4096.
66
 
  -s TYPE, --subtype TYPE
67
 
                        Subkey type.  Default is RSA.
68
 
  -L BITS, --sublength BITS
69
 
                        Subkey length in bits.  Default is 4096.
70
 
  -n NAME, --name NAME  Name of key.  Default is the FQDN.
71
 
  -e ADDRESS, --email ADDRESS
72
 
                        Email address of key.  Default is empty.
73
 
  -c TEXT, --comment TEXT
74
 
                        Comment field for key.  The default is empty.
75
 
  -x TIME, --expire TIME
76
 
                        Key expire time.  Default is no expiration.
77
 
                        See gpg(1) for syntax.
78
 
  -f, --force           Force overwriting old key files.
79
 
 
80
 
Password creation options:
81
 
  -p, --password        Create an encrypted password using the key in
82
 
                        the key directory.  All options other than
83
 
                        --dir and --name are ignored.
84
 
  -F FILE, --passfile FILE
85
 
                        Encrypt a password from FILE using the key in
86
 
                        the key directory.  All options other than
87
 
                        --dir and --name are ignored.
88
 
EOF
89
 
}
90
 
 
91
 
eval set -- "$TEMP"
92
 
while :; do
93
 
    case "$1" in
94
 
        -p|--password) mode=password; shift;;
95
 
        -F|--passfile) mode=password; PASSFILE="$2"; shift 2;;
96
 
        -d|--dir) KEYDIR="$2"; shift 2;;
97
 
        -t|--type) KEYTYPE="$2"; shift 2;;
98
 
        -s|--subtype) SUBKEYTYPE="$2"; shift 2;;
99
 
        -l|--length) KEYLENGTH="$2"; shift 2;;
100
 
        -L|--sublength) SUBKEYLENGTH="$2"; shift 2;;
101
 
        -n|--name) KEYNAME="$2"; shift 2;;
102
 
        -e|--email) KEYEMAIL="$2"; shift 2;;
103
 
        -c|--comment) KEYCOMMENT="$2"; shift 2;;
104
 
        -x|--expire) KEYEXPIRE="$2"; shift 2;;
105
 
        -f|--force) FORCE=yes; shift;;
106
 
        -v|--version) echo "$0 $VERSION"; exit;;
107
 
        -h|--help) help; exit;;
108
 
        --) shift; break;;
109
 
        *) echo "Internal error" >&2; exit 1;;
110
 
    esac
111
 
done
112
 
if [ "$#" -gt 0 ]; then
113
 
    echo "Unknown arguments: '$@'" >&2
114
 
    exit 1
115
 
fi
116
 
 
117
 
SECKEYFILE="$KEYDIR/seckey.txt"
118
 
PUBKEYFILE="$KEYDIR/pubkey.txt"
119
 
 
120
 
# Check for some invalid values
121
 
if [ ! -d "$KEYDIR" ]; then
122
 
    echo "$KEYDIR not a directory" >&2
123
 
    exit 1
124
 
fi
125
 
if [ ! -r "$KEYDIR" ]; then
126
 
    echo "Directory $KEYDIR not readable" >&2
127
 
    exit 1
128
 
fi
129
 
 
130
 
if [ "$mode" = keygen ]; then
131
 
    if [ ! -w "$KEYDIR" ]; then
132
 
        echo "Directory $KEYDIR not writeable" >&2
133
 
        exit 1
134
 
    fi
135
 
    if [ -z "$KEYTYPE" ]; then
136
 
        echo "Empty key type" >&2
137
 
        exit 1
138
 
    fi
139
 
    
140
 
    if [ -z "$KEYNAME" ]; then
141
 
        echo "Empty key name" >&2
142
 
        exit 1
143
 
    fi
144
 
    
145
 
    if [ -z "$KEYLENGTH" ] || [ "$KEYLENGTH" -lt 512 ]; then
146
 
        echo "Invalid key length" >&2
147
 
        exit 1
148
 
    fi
149
 
    
150
 
    if [ -z "$KEYEXPIRE" ]; then
151
 
        echo "Empty key expiration" >&2
152
 
        exit 1
153
 
    fi
154
 
    
155
 
    # Make FORCE be 0 or 1
156
 
    case "$FORCE" in
157
 
        [Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]) FORCE=1;;
158
 
        [Nn][Oo]|[Ff][Aa][Ll][Ss][Ee]|*) FORCE=0;;
159
 
    esac
160
 
    
161
 
    if [ \( -e "$SECKEYFILE" -o -e "$PUBKEYFILE" \) \
162
 
        -a "$FORCE" -eq 0 ]; then
163
 
        echo "Refusing to overwrite old key files; use --force" >&2
164
 
        exit 1
165
 
    fi
166
 
    
167
 
    # Set lines for GnuPG batch file
168
 
    if [ -n "$KEYCOMMENT" ]; then
169
 
        KEYCOMMENTLINE="Name-Comment: $KEYCOMMENT"
170
 
    fi
171
 
    if [ -n "$KEYEMAIL" ]; then
172
 
        KEYEMAILLINE="Name-Email: $KEYEMAIL"
173
 
    fi
174
 
    
175
 
    # Create temporary gpg batch file
176
 
    BATCHFILE="`mktemp -t mandos-keygen-batch.XXXXXXXXXX`"
177
 
fi
178
 
 
179
 
if [ "$mode" = password ]; then
180
 
    # Create temporary encrypted password file
181
 
    SECFILE="`mktemp -t mandos-keygen-secfile.XXXXXXXXXX`"
182
 
fi
183
 
 
184
 
# Create temporary key ring directory
185
 
RINGDIR="`mktemp -d -t mandos-keygen-keyrings.XXXXXXXXXX`"
186
 
 
187
 
# Remove temporary files on exit
188
 
trap "
189
 
set +e; \
190
 
test -n \"$SECFILE\" && shred --remove \"$SECFILE\"; \
191
 
shred --remove \"$RINGDIR\"/sec*;
192
 
test -n \"$BATCHFILE\" && rm --force \"$BATCHFILE\"; \
193
 
rm --recursive --force \"$RINGDIR\";
194
 
tty --quiet && stty echo; \
195
 
" EXIT
196
 
 
197
 
set -e
198
 
 
199
 
umask 077
200
 
 
201
 
if [ "$mode" = keygen ]; then
202
 
    # Create batch file for GnuPG
203
 
    cat >"$BATCHFILE" <<-EOF
204
 
        Key-Type: $KEYTYPE
205
 
        Key-Length: $KEYLENGTH
206
 
        Key-Usage: sign,auth
207
 
        Subkey-Type: $SUBKEYTYPE
208
 
        Subkey-Length: $SUBKEYLENGTH
209
 
        Subkey-Usage: encrypt
210
 
        Name-Real: $KEYNAME
211
 
        $KEYCOMMENTLINE
212
 
        $KEYEMAILLINE
213
 
        Expire-Date: $KEYEXPIRE
214
 
        #Preferences: <string>
215
 
        #Handle: <no-spaces>
216
 
        #%pubring pubring.gpg
217
 
        #%secring secring.gpg
218
 
        %commit
219
 
        EOF
220
 
    
221
 
    if tty --quiet; then
222
 
        cat <<-EOF
223
 
        Note: Due to entropy requirements, key generation could take
224
 
        anything from a few minutes to SEVERAL HOURS.  Please be
225
 
        patient and/or supply the system with more entropy if needed.
226
 
        EOF
227
 
        echo -n "Started: "
228
 
        date
229
 
    fi
230
 
    
231
 
    # Generate a new key in the key rings
232
 
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
233
 
        --homedir "$RINGDIR" --trust-model always \
234
 
        --gen-key "$BATCHFILE"
235
 
    rm --force "$BATCHFILE"
236
 
    
237
 
    if tty --quiet; then
238
 
        echo -n "Finished: "
239
 
        date
240
 
    fi
241
 
    
242
 
    # Backup any old key files
243
 
    if cp --backup=numbered --force "$SECKEYFILE" "$SECKEYFILE" \
244
 
        2>/dev/null; then
245
 
        shred --remove "$SECKEYFILE"
246
 
    fi
247
 
    if cp --backup=numbered --force "$PUBKEYFILE" "$PUBKEYFILE" \
248
 
        2>/dev/null; then
249
 
        rm --force "$PUBKEYFILE"
250
 
    fi
251
 
    
252
 
    FILECOMMENT="Mandos client key for $KEYNAME"
253
 
    if [ "$KEYCOMMENT" != "$KEYCOMMENT_ORIG" ]; then
254
 
        FILECOMMENT="$FILECOMMENT ($KEYCOMMENT)"
255
 
    fi
256
 
    
257
 
    if [ -n "$KEYEMAIL" ]; then
258
 
        FILECOMMENT="$FILECOMMENT <$KEYEMAIL>"
259
 
    fi
260
 
    
261
 
    # Export key from key rings to key files
262
 
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
263
 
        --homedir "$RINGDIR" --armor --export-options export-minimal \
264
 
        --comment "$FILECOMMENT" --output "$SECKEYFILE" \
265
 
        --export-secret-keys
266
 
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
267
 
        --homedir "$RINGDIR" --armor --export-options export-minimal \
268
 
        --comment "$FILECOMMENT" --output "$PUBKEYFILE" --export
269
 
fi
270
 
 
271
 
if [ "$mode" = password ]; then
272
 
    # Import key into temporary key rings
273
 
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
274
 
        --homedir "$RINGDIR" --trust-model always --armor \
275
 
        --import "$SECKEYFILE"
276
 
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
277
 
        --homedir "$RINGDIR" --trust-model always --armor \
278
 
        --import "$PUBKEYFILE"
279
 
    
280
 
    # Get fingerprint of key
281
 
    FINGERPRINT="`gpg --quiet --batch --no-tty --no-options \
282
 
        --enable-dsa2 --homedir \"$RINGDIR\" --trust-model always \
283
 
        --fingerprint --with-colons \
284
 
        | sed --quiet \
285
 
        --expression='/^fpr:/{s/^fpr:.*:\\([0-9A-Z]*\\):\$/\\1/p;q}'`"
286
 
    
287
 
    test -n "$FINGERPRINT"
288
 
    
289
 
    FILECOMMENT="Encrypted password for a Mandos client"
290
 
    
291
 
    while [ ! -s "$SECFILE" ]; do
292
 
        if [ -n "$PASSFILE" ]; then
293
 
            cat "$PASSFILE"
294
 
        else
295
 
            tty --quiet && stty -echo
296
 
            echo -n "Enter passphrase: " >&2
297
 
            read first
298
 
            tty --quiet && echo >&2
299
 
            echo -n "Repeat passphrase: " >&2
300
 
            read second
301
 
            if tty --quiet; then
302
 
                echo >&2
303
 
                stty echo
304
 
            fi
305
 
            if [ "$first" != "$second" ]; then
306
 
                echo "Passphrase mismatch" >&2
307
 
                touch "$RINGDIR"/mismatch
308
 
            else
309
 
                echo -n "$first"
310
 
            fi
311
 
        fi | gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
312
 
            --homedir "$RINGDIR" --trust-model always --armor \
313
 
            --encrypt --sign --recipient "$FINGERPRINT" --comment \
314
 
            "$FILECOMMENT" > "$SECFILE"
315
 
        if [ -e "$RINGDIR"/mismatch ]; then
316
 
            rm --force "$RINGDIR"/mismatch
317
 
            if tty --quiet; then
318
 
                > "$SECFILE"
319
 
            else
320
 
                exit 1
321
 
            fi
322
 
        fi
323
 
    done
324
 
    
325
 
    cat <<-EOF
326
 
        [$KEYNAME]
327
 
        host = $KEYNAME
328
 
        fingerprint = $FINGERPRINT
329
 
        secret =
330
 
        EOF
331
 
    sed --quiet --expression='
332
 
        /^-----BEGIN PGP MESSAGE-----$/,/^-----END PGP MESSAGE-----$/{
333
 
            /^$/,${
334
 
                # Remove 24-bit Radix-64 checksum
335
 
                s/=....$//
336
 
                # Indent four spaces
337
 
                /^[^-]/s/^/    /p
338
 
            }
339
 
        }' < "$SECFILE"
340
 
fi
341
 
 
342
 
trap - EXIT
343
 
 
344
 
set +e
345
 
# Remove the password file, if any
346
 
if [ -n "$SECFILE" ]; then
347
 
    shred --remove "$SECFILE"
348
 
fi
349
 
# Remove the key rings
350
 
shred --remove "$RINGDIR"/sec*
351
 
rm --recursive --force "$RINGDIR"