/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: Teddy Hogeborn
  • Date: 2008-07-20 06:33:48 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080720063348-jscgy5p0itrgvlo8
* mandos-clients.conf ([foo]): Uncommented.
  ([foo]/secret): New.
  ([foo]/secfile): Commented out.
  ([foo]/checker): Changed to "fping -q -- %%(fqdn)s".
  ([foo]/timeout): New.

* server.py: New modeline for Python and Emacs.  Set a logging format.
  (Client.__init__): Bug fix: Choose either the value from the options
                     object or pass the argument through string_to_delta
                     for both "timeout" and "interval".
  (Client.checker_callback): Bug fix: Do not log spurious "Checker for
                             <foo> failed" messages.
  (Client.start_checker): Moved "Starting checker" log message down to
                          just before actually starting the subprocess.
                          Do not redirect the subprocesses' stdout to a
                          pipe.
  (peer_certificate, fingerprint): Added docstrings.
  (entry_group_state_changed): Call "killme()" instead of
                               "main_loop.quit()".
  (daemon, killme): New functions.
  (exitstatus, main_loop_started): New global variables.
  (__main__): Removed the "--cert", "--key", "--ca", and "--crl"
              options.  Removed the sleep command from the default
              checker.  Add a console logger in debug mode.  Call
              "killme()" instead of "main_loop.quit()" when there are no
              more clients.  Call "daemon()" if not in debug mode.
              Register "cleanup()" to run at exit.  Ignore some
              signals.  Catch DBusException to detect another running
              server and exit cleanly.  Exit with "exitstatus".
  (cleanup): New function.

Show diffs side-by-side

added added

removed removed

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