/mandos/trunk

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

« back to all changes in this revision

Viewing changes to mandos-keygen

  • Committer: Teddy Hogeborn
  • Date: 2008-08-16 03:29:08 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080816032908-ihw7c05r2mnyk389
Add feature to specify custom environment variables for plugins.

* plugin-runner.c (plugin): New members "environ" and "envc" to
                            contain possible custom environment.
  (getplugin): Return NULL on failure instead of doing exit(); all
               callers changed.
  (add_to_char_array): New helper function for "add_argument" and
                       "add_environment".
  (addargument): Renamed to "add_argument".  Return bool.  Call
                 "add_to_char_array" to actually do things.
  (add_environment): New; analogous to "add_argument".
  (addcustomargument): Renamed to "add_to_argv" to avoid confusion
                       with "add_argument".
  (main): New options "--global-envs" and "--envs-for" to specify
          custom environment for plugins.  Print environment for
          plugins in debug mode.  Use asprintf instead of strcpy and
          strcat.  Use execve() for plugins with custom environments.
          Free environment for plugin when freeing plugin list.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-keygen
1
1
#!/bin/sh -e
2
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
 
3
# Mandos key generator - create a new OpenPGP key for a Mandos client
 
4
# 
 
5
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
 
6
# 
 
7
# This program is free software: you can redistribute it and/or modify
 
8
# it under the terms of the GNU General Public License as published by
12
9
# the Free Software Foundation, either version 3 of the License, or
13
10
# (at your option) any later version.
14
11
#
15
 
#     Mandos is distributed in the hope that it will be useful, but
16
 
#     WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
#     This program is distributed in the hope that it will be useful,
 
13
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
17
14
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
15
#     GNU General Public License for more details.
19
16
# 
20
17
# 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.9"
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`"
 
18
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
19
# 
 
20
# Contact the authors at <mandos@fukt.bsnet.se>.
 
21
# 
 
22
 
 
23
VERSION="1.0"
 
24
 
 
25
KEYDIR="/etc/mandos"
 
26
KEYTYPE=DSA
 
27
KEYLENGTH=1024
 
28
KEYNAME="`hostname --fqdn`"
34
29
KEYEMAIL=""
35
 
KEYCOMMENT=""
 
30
KEYCOMMENT="Mandos client key"
36
31
KEYEXPIRE=0
37
 
TLS_KEYTYPE=ed25519
38
32
FORCE=no
39
 
SSH=yes
40
33
KEYCOMMENT_ORIG="$KEYCOMMENT"
41
 
mode=keygen
42
 
 
43
 
if [ ! -d "$KEYDIR" ]; then
44
 
    KEYDIR="/etc/mandos/keys"
45
 
fi
46
34
 
47
35
# 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 \
 
36
TEMP=`getopt --options vhd:t:l:n:e:c:x:f \
 
37
    --longoptions version,help,dir:,type:,length:,name:,email:,comment:,expire:,force \
50
38
    --name "$0" -- "$@"`
51
39
 
52
40
help(){
53
 
basename="`basename "$0"`"
54
41
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]
 
42
Usage: `basename $0` [options]
62
43
 
63
 
Key creation options:
 
44
Options:
64
45
  -v, --version         Show program's version number and exit
65
46
  -h, --help            Show this help message and exit
66
47
  -d DIR, --dir DIR     Target directory for key files
67
 
  -t TYPE, --type TYPE  OpenPGP key type.  Default is RSA.
 
48
  -t TYPE, --type TYPE  Key type.  Default is DSA.
68
49
  -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.
 
50
                        Key length in bits.  Default is 1024.
74
51
  -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.
 
52
  -e EMAIL, --email EMAIL
 
53
                        Email address of key.  Default is empty.
 
54
  -c COMMENT, --comment COMMENT
 
55
                        Comment field for key.  The default value is
 
56
                        "Mandos client key".
79
57
  -x TIME, --expire TIME
80
 
                        OpenPGP key expire time.  Default is none.
 
58
                        Key expire time.  Default is no expiration.
81
59
                        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.
 
60
  -f, --force           Force overwriting old keys.
95
61
EOF
96
62
}
97
63
 
98
64
eval set -- "$TEMP"
99
65
while :; do
100
66
    case "$1" in
101
 
        -p|--password) mode=password; shift;;
102
 
        -F|--passfile) mode=password; PASSFILE="$2"; shift 2;;
103
67
        -d|--dir) KEYDIR="$2"; shift 2;;
104
68
        -t|--type) KEYTYPE="$2"; shift 2;;
105
 
        -s|--subtype) SUBKEYTYPE="$2"; shift 2;;
106
69
        -l|--length) KEYLENGTH="$2"; shift 2;;
107
 
        -L|--sublength) SUBKEYLENGTH="$2"; shift 2;;
108
70
        -n|--name) KEYNAME="$2"; shift 2;;
109
71
        -e|--email) KEYEMAIL="$2"; shift 2;;
110
72
        -c|--comment) KEYCOMMENT="$2"; shift 2;;
111
 
        -x|--expire) KEYEXPIRE="$2"; shift 2;;
112
 
        -T|--tls-keytype) TLS_KEYTYPE="$2"; shift 2;;
 
73
        -x|--expire) KEYCOMMENT="$2"; shift 2;;
113
74
        -f|--force) FORCE=yes; shift;;
114
 
        -S|--no-ssh) SSH=no; shift;;
115
75
        -v|--version) echo "$0 $VERSION"; exit;;
116
76
        -h|--help) help; exit;;
117
77
        --) shift; break;;
119
79
    esac
120
80
done
121
81
if [ "$#" -gt 0 ]; then
122
 
    echo "Unknown arguments: '$*'" >&2
 
82
    echo "Unknown arguments: '$@'" >&2
123
83
    exit 1
124
84
fi
125
85
 
126
86
SECKEYFILE="$KEYDIR/seckey.txt"
127
87
PUBKEYFILE="$KEYDIR/pubkey.txt"
128
 
TLS_PRIVKEYFILE="$KEYDIR/tls-privkey.pem"
129
 
TLS_PUBKEYFILE="$KEYDIR/tls-pubkey.pem"
130
88
 
131
89
# Check for some invalid values
132
 
if [ ! -d "$KEYDIR" ]; then
 
90
if [ -d "$KEYDIR" ]; then :; else
133
91
    echo "$KEYDIR not a directory" >&2
134
92
    exit 1
135
93
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`"
 
94
if [ -w "$KEYDIR" ]; then :; else
 
95
    echo "Directory $KEYDIR not writeable" >&2
 
96
    exit 1
 
97
fi
 
98
 
 
99
if [ -z "$KEYTYPE" ]; then
 
100
    echo "Empty key type" >&2
 
101
    exit 1
 
102
fi
 
103
 
 
104
if [ -z "$KEYNAME" ]; then
 
105
    echo "Empty key name" >&2
 
106
    exit 1
 
107
fi
 
108
 
 
109
if [ -z "$KEYLENGTH" ] || [ "$KEYLENGTH" -lt 512 ]; then
 
110
    echo "Invalid key length" >&2
 
111
    exit 1
 
112
fi
 
113
 
 
114
if [ -z "$KEYEXPIRE" ]; then
 
115
    echo "Empty key expiration" >&2
 
116
    exit 1
 
117
fi
 
118
 
 
119
# Make FORCE be 0 or 1
 
120
case "$FORCE" in
 
121
    [Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]) FORCE=1;;
 
122
    [Nn][Oo]|[Ff][Aa][Ll][Ss][Ee]|*) FORCE=0;;
 
123
esac
 
124
 
 
125
if { [ -e "$SECKEYFILE" ] || [ -e "$PUBKEYFILE" ]; } \
 
126
    && [ "$FORCE" -eq 0 ]; then
 
127
    echo "Refusing to overwrite old key files; use --force" >&2
 
128
    exit 1
 
129
fi
 
130
 
 
131
# Set lines for GnuPG batch file
 
132
if [ -n "$KEYCOMMENT" ]; then
 
133
    KEYCOMMENTLINE="Name-Comment: $KEYCOMMENT"
 
134
fi
 
135
if [ -n "$KEYEMAIL" ]; then
 
136
    KEYEMAILLINE="Name-Email: $KEYEMAIL"
 
137
fi
 
138
 
 
139
# Create temp files
 
140
BATCHFILE="`mktemp -t mandos-gpg-batch.XXXXXXXXXX`"
 
141
SECRING="`mktemp -t mandos-gpg-secring.XXXXXXXXXX`"
 
142
PUBRING="`mktemp -t mandos-gpg-pubring.XXXXXXXXXX`"
200
143
 
201
144
# 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
 
145
trap "rm --force $PUBRING $BATCHFILE; shred --remove $SECRING" EXIT
 
146
 
 
147
# Create batch file for GnuPG
 
148
cat >"$BATCHFILE" <<EOF
 
149
Key-Type: $KEYTYPE
 
150
Key-Length: $KEYLENGTH
 
151
#Key-Usage: encrypt,sign,auth
 
152
Name-Real: $KEYNAME
 
153
$KEYCOMMENTLINE
 
154
$KEYEMAILLINE
 
155
Expire-Date: $KEYEXPIRE
 
156
%pubring $PUBRING
 
157
%secring $SECRING
 
158
%commit
 
159
EOF
 
160
 
 
161
umask 027
 
162
 
 
163
# Generate a new key in the key rings
 
164
gpg --no-random-seed-file --quiet --batch --no-tty \
 
165
    --no-default-keyring --no-options --batch \
 
166
    --secret-keyring "$SECRING" --keyring "$PUBRING" \
 
167
    --gen-key "$BATCHFILE"
 
168
rm --force "$BATCHFILE"
 
169
 
 
170
# Backup any old key files
 
171
if cp --backup=numbered --force "$SECKEYFILE" "$SECKEYFILE" \
 
172
    2>/dev/null; then
 
173
    shred --remove "$SECKEYFILE"
 
174
fi
 
175
if cp --backup=numbered --force "$PUBKEYFILE" "$PUBKEYFILE" \
 
176
    2>/dev/null; then
 
177
    rm --force "$PUBKEYFILE"
 
178
fi
 
179
 
 
180
FILECOMMENT="Mandos client key for $KEYNAME"
 
181
if [ "$KEYCOMMENT" != "$KEYCOMMENT_ORIG" ]; then
 
182
    FILECOMMENT="$FILECOMMENT ($KEYCOMMENT)"
 
183
fi
 
184
 
 
185
if [ -n "$KEYEMAIL" ]; then
 
186
    FILECOMMENT="$FILECOMMENT <$KEYEMAIL>"
 
187
fi
 
188
 
 
189
# Export keys from key rings to key files
 
190
gpg --no-random-seed-file --quiet --batch --no-tty --armor \
 
191
    --no-default-keyring --secret-keyring "$SECRING" \
 
192
    --keyring "$PUBRING" --export-options export-minimal \
 
193
    --comment "$FILECOMMENT" --output "$SECKEYFILE" \
 
194
    --export-secret-keys
 
195
gpg --no-random-seed-file --quiet --batch --no-tty --armor \
 
196
    --no-default-keyring --secret-keyring "$SECRING" \
 
197
    --keyring "$PUBRING" --export-options export-minimal \
 
198
    --comment "$FILECOMMENT" --output "$PUBKEYFILE" \
 
199
    --export
441
200
 
442
201
trap - EXIT
443
202
 
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
203
# Remove the key rings
450
 
shred --remove "$RINGDIR"/sec* 2>/dev/null
451
 
rm --recursive --force "$RINGDIR"
 
204
shred --remove "$SECRING"
 
205
rm --force "$PUBRING"