/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: Björn Påhlsson
  • Date: 2008-07-20 02:52:20 UTC
  • Revision ID: belorn@braxen-20080720025220-r5u0388uy9iu23h6
Added following support:
Pluginbased client handler
rewritten Mandos client
       Avahi instead of udp server discovery
       openpgp encrypted key support
Passprompt stand alone application for direct console input
Added logging for Mandos server

Show diffs side-by-side

added added

removed removed

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