/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: 2015-07-20 03:03:33 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150720030333-203m2aeblypcsfte
Bug fix for GnuTLS 3: be compatible with old 2048-bit DSA keys.

The mandos-keygen program in Mandos version 1.6.0 and older generated
2048-bit DSA keys, and when GnuTLS uses these it has trouble
connecting using the Mandos default priority string.  This was
previously fixed in Mandos 1.6.2, but the bug reappeared when using
GnuTLS 3, so the default priority string has to change again; this
time also the Mandos client has to change its default, so now the
server and the client should use the same default priority string:

SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256

* mandos (main/server_defaults): Changed default priority string.
* mandos-options.xml (/section/para[id="priority_compat"]): Removed.
  (/section/para[id="priority"]): Changed default priority string.
* mandos.conf ([DEFAULT]/priority): - '' -
* mandos.conf.xml (OPTIONS/priority): Refer to the id "priority"
                                      instead of "priority_compat".
* mandos.xml (OPTIONS/--priority): - '' -
* plugins.d/mandos-client.c (main): Changed default priority string.

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