/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: 2018-08-15 09:26:02 UTC
  • Revision ID: teddy@recompile.se-20180815092602-xoyb5s6gf8376i7u
http://bugs.debian.org/894495
mandos-client: Set system clock if necessary

* plugins.d/mandos-client.c (init_gpgme/import_key): If the system
  clock is not set, or set to january 1970, set the system clock to
  the more plausible value that is the mtime of the key file.  This is
  required by GnuPG to be able to import the keys.  (We can't pass the
  --ignore-time-conflict or the --ignore-valid-from options though
  GPGME.)

Show diffs side-by-side

added added

removed removed

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