/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: 2019-07-29 16:35:53 UTC
  • Revision ID: teddy@recompile.se-20190729163553-1i442i2cbx64c537
Make tests and man page examples match

Make the tests test_manual_page_example[1-5] match exactly what is
written in the manual page, and add comments to manual page as
reminders to keep tests and manual page examples in sync.

* mandos-ctl (Test_commands_from_options.test_manual_page_example_1):
  Remove "--verbose" option, since the manual does not have it as the
  first example, and change assertion to match.
* mandos-ctl.xml (EXAMPLE): Add comments to all examples documenting
  which test function they correspond to.  Also remove unnecessary
  quotes from option arguments in fourth example, and clarify language
  slightly in fifth example.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
#!/bin/sh -e
2
2
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
 
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
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.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`"
29
34
KEYEMAIL=""
30
 
KEYCOMMENT="Mandos client key"
 
35
KEYCOMMENT=""
31
36
KEYEXPIRE=0
 
37
TLS_KEYTYPE=ed25519
32
38
FORCE=no
 
39
SSH=yes
33
40
KEYCOMMENT_ORIG="$KEYCOMMENT"
 
41
mode=keygen
 
42
 
 
43
if [ ! -d "$KEYDIR" ]; then
 
44
    KEYDIR="/etc/mandos/keys"
 
45
fi
34
46
 
35
47
# 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 \
 
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 \
38
50
    --name "$0" -- "$@"`
39
51
 
40
52
help(){
 
53
basename="`basename "$0"`"
41
54
cat <<EOF
42
 
Usage: `basename $0` [options]
 
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]
43
62
 
44
 
Options:
 
63
Key creation options:
45
64
  -v, --version         Show program's version number and exit
46
65
  -h, --help            Show this help message and exit
47
66
  -d DIR, --dir DIR     Target directory for key files
48
 
  -t TYPE, --type TYPE  Key type.  Default is DSA.
 
67
  -t TYPE, --type TYPE  OpenPGP key type.  Default is RSA.
49
68
  -l BITS, --length BITS
50
 
                        Key length in bits.  Default is 1024.
 
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.
51
74
  -n NAME, --name NAME  Name of key.  Default is the FQDN.
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".
 
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.
57
79
  -x TIME, --expire TIME
58
 
                        Key expire time.  Default is no expiration.
 
80
                        OpenPGP key expire time.  Default is none.
59
81
                        See gpg(1) for syntax.
60
 
  -f, --force           Force overwriting old keys.
 
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.
61
95
EOF
62
96
}
63
97
 
64
98
eval set -- "$TEMP"
65
99
while :; do
66
100
    case "$1" in
 
101
        -p|--password) mode=password; shift;;
 
102
        -F|--passfile) mode=password; PASSFILE="$2"; shift 2;;
67
103
        -d|--dir) KEYDIR="$2"; shift 2;;
68
104
        -t|--type) KEYTYPE="$2"; shift 2;;
 
105
        -s|--subtype) SUBKEYTYPE="$2"; shift 2;;
69
106
        -l|--length) KEYLENGTH="$2"; shift 2;;
 
107
        -L|--sublength) SUBKEYLENGTH="$2"; shift 2;;
70
108
        -n|--name) KEYNAME="$2"; shift 2;;
71
109
        -e|--email) KEYEMAIL="$2"; shift 2;;
72
110
        -c|--comment) KEYCOMMENT="$2"; shift 2;;
73
 
        -x|--expire) KEYCOMMENT="$2"; shift 2;;
 
111
        -x|--expire) KEYEXPIRE="$2"; shift 2;;
 
112
        -T|--tls-keytype) TLS_KEYTYPE="$2"; shift 2;;
74
113
        -f|--force) FORCE=yes; shift;;
 
114
        -S|--no-ssh) SSH=no; shift;;
75
115
        -v|--version) echo "$0 $VERSION"; exit;;
76
116
        -h|--help) help; exit;;
77
117
        --) shift; break;;
79
119
    esac
80
120
done
81
121
if [ "$#" -gt 0 ]; then
82
 
    echo "Unknown arguments: '$@'" >&2
 
122
    echo "Unknown arguments: '$*'" >&2
83
123
    exit 1
84
124
fi
85
125
 
86
126
SECKEYFILE="$KEYDIR/seckey.txt"
87
127
PUBKEYFILE="$KEYDIR/pubkey.txt"
 
128
TLS_PRIVKEYFILE="$KEYDIR/tls-privkey.pem"
 
129
TLS_PUBKEYFILE="$KEYDIR/tls-pubkey.pem"
88
130
 
89
131
# Check for some invalid values
90
 
if [ -d "$KEYDIR" ]; then :; else
 
132
if [ ! -d "$KEYDIR" ]; then
91
133
    echo "$KEYDIR not a directory" >&2
92
134
    exit 1
93
135
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`"
 
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`"
143
200
 
144
201
# 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
 
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
200
441
 
201
442
trap - EXIT
202
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
203
449
# Remove the key rings
204
 
shred --remove "$SECRING"
205
 
rm --force "$PUBRING"
 
450
shred --remove "$RINGDIR"/sec* 2>/dev/null
 
451
rm --recursive --force "$RINGDIR"