/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
2
2
# 
3
3
# Mandos key generator - create a new OpenPGP key for a Mandos client
4
4
# 
5
 
# Copyright © 2008 Teddy Hogeborn & Björn Påhlsson
 
5
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
6
6
# 
7
7
# This program is free software: you can redistribute it and/or modify
8
8
# it under the terms of the GNU General Public License as published by
22
22
 
23
23
VERSION="1.0"
24
24
 
25
 
KEYDIR="/etc/keys/mandos"
 
25
KEYDIR="/etc/mandos"
26
26
KEYTYPE=DSA
27
 
KEYLENGTH=2048
28
 
SUBKEYTYPE=ELG-E
29
 
SUBKEYLENGTH=2048
30
 
KEYNAME="`hostname --fqdn 2>/dev/null || hostname`"
 
27
KEYLENGTH=1024
 
28
KEYNAME="`hostname --fqdn`"
31
29
KEYEMAIL=""
32
30
KEYCOMMENT="Mandos client key"
33
31
KEYEXPIRE=0
34
32
FORCE=no
35
33
KEYCOMMENT_ORIG="$KEYCOMMENT"
36
 
mode=keygen
37
 
 
38
 
if [ ! -d "$KEYDIR" ]; then
39
 
    KEYDIR="/etc/mandos/keys"
40
 
fi
41
34
 
42
35
# Parse options
43
 
TEMP=`getopt --options vhpF:d:t:l:s:L:n:e:c:x:f \
44
 
    --longoptions version,help,password,passfile:,dir:,type:,length:,subtype:,sublength:,name:,email:,comment:,expire:,force \
 
36
TEMP=`getopt --options vhd:t:l:n:e:c:x:f \
 
37
    --longoptions version,help,dir:,type:,length:,name:,email:,comment:,expire:,force \
45
38
    --name "$0" -- "$@"`
46
39
 
47
40
help(){
48
 
basename="`basename $0`"
49
41
cat <<EOF
50
 
Usage: $basename [ -v | --version ]
51
 
       $basename [ -h | --help ]
52
 
   Key creation:
53
 
       $basename [ OPTIONS ]
54
 
   Encrypted password creation:
55
 
       $basename { -p | --password } [ --name NAME ] [ --dir DIR]
56
 
       $basename { -F | --passfile } FILE [ --name NAME ] [ --dir DIR]
 
42
Usage: `basename $0` [options]
57
43
 
58
 
Key creation options:
 
44
Options:
59
45
  -v, --version         Show program's version number and exit
60
46
  -h, --help            Show this help message and exit
61
47
  -d DIR, --dir DIR     Target directory for key files
62
48
  -t TYPE, --type TYPE  Key type.  Default is DSA.
63
49
  -l BITS, --length BITS
64
 
                        Key length in bits.  Default is 2048.
65
 
  -s TYPE, --subtype TYPE
66
 
                        Subkey type.  Default is ELG-E.
67
 
  -L BITS, --sublength BITS
68
 
                        Subkey length in bits.  Default is 2048.
 
50
                        Key length in bits.  Default is 1024.
69
51
  -n NAME, --name NAME  Name of key.  Default is the FQDN.
70
 
  -e ADDRESS, --email ADDRESS
 
52
  -e EMAIL, --email EMAIL
71
53
                        Email address of key.  Default is empty.
72
 
  -c TEXT, --comment TEXT
 
54
  -c COMMENT, --comment COMMENT
73
55
                        Comment field for key.  The default value is
74
56
                        "Mandos client key".
75
57
  -x TIME, --expire TIME
76
58
                        Key expire time.  Default is no expiration.
77
59
                        See gpg(1) for syntax.
78
 
  -f, --force           Force overwriting old key files.
79
 
 
80
 
Password creation options:
81
 
  -p, --password        Create an encrypted password using the key in
82
 
                        the key directory.  All options other than
83
 
                        --dir and --name are ignored.
84
 
  -F FILE, --passfile FILE
85
 
                        Encrypt a password from FILE using the key in
86
 
                        the key directory.  All options other than
87
 
                        --dir and --name are ignored.
 
60
  -f, --force           Force overwriting old keys.
88
61
EOF
89
62
}
90
63
 
91
64
eval set -- "$TEMP"
92
65
while :; do
93
66
    case "$1" in
94
 
        -p|--password) mode=password; shift;;
95
 
        -F|--passfile) mode=password; PASSFILE="$2"; shift 2;;
96
67
        -d|--dir) KEYDIR="$2"; shift 2;;
97
68
        -t|--type) KEYTYPE="$2"; shift 2;;
98
 
        -s|--subtype) SUBKEYTYPE="$2"; shift 2;;
99
69
        -l|--length) KEYLENGTH="$2"; shift 2;;
100
 
        -L|--sublength) SUBKEYLENGTH="$2"; shift 2;;
101
70
        -n|--name) KEYNAME="$2"; shift 2;;
102
71
        -e|--email) KEYEMAIL="$2"; shift 2;;
103
72
        -c|--comment) KEYCOMMENT="$2"; shift 2;;
104
 
        -x|--expire) KEYEXPIRE="$2"; shift 2;;
 
73
        -x|--expire) KEYCOMMENT="$2"; shift 2;;
105
74
        -f|--force) FORCE=yes; shift;;
106
75
        -v|--version) echo "$0 $VERSION"; exit;;
107
76
        -h|--help) help; exit;;
118
87
PUBKEYFILE="$KEYDIR/pubkey.txt"
119
88
 
120
89
# Check for some invalid values
121
 
if [ ! -d "$KEYDIR" ]; then
 
90
if [ -d "$KEYDIR" ]; then :; else
122
91
    echo "$KEYDIR not a directory" >&2
123
92
    exit 1
124
93
fi
125
 
if [ ! -r "$KEYDIR" ]; then
126
 
    echo "Directory $KEYDIR not readable" >&2
127
 
    exit 1
128
 
fi
129
 
 
130
 
if [ "$mode" = keygen ]; then
131
 
    if [ ! -w "$KEYDIR" ]; then
132
 
        echo "Directory $KEYDIR not writeable" >&2
133
 
        exit 1
134
 
    fi
135
 
    if [ -z "$KEYTYPE" ]; then
136
 
        echo "Empty key type" >&2
137
 
        exit 1
138
 
    fi
139
 
    
140
 
    if [ -z "$KEYNAME" ]; then
141
 
        echo "Empty key name" >&2
142
 
        exit 1
143
 
    fi
144
 
    
145
 
    if [ -z "$KEYLENGTH" ] || [ "$KEYLENGTH" -lt 512 ]; then
146
 
        echo "Invalid key length" >&2
147
 
        exit 1
148
 
    fi
149
 
 
150
 
    if [ -z "$KEYEXPIRE" ]; then
151
 
        echo "Empty key expiration" >&2
152
 
        exit 1
153
 
    fi
154
 
    
155
 
    # Make FORCE be 0 or 1
156
 
    case "$FORCE" in
157
 
        [Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]) FORCE=1;;
158
 
        [Nn][Oo]|[Ff][Aa][Ll][Ss][Ee]|*) FORCE=0;;
159
 
    esac
160
 
    
161
 
    if [ \( -e "$SECKEYFILE" -o -e "$PUBKEYFILE" \) \
162
 
        -a "$FORCE" -eq 0 ]; then
163
 
        echo "Refusing to overwrite old key files; use --force" >&2
164
 
        exit 1
165
 
    fi
166
 
    
167
 
    # Set lines for GnuPG batch file
168
 
    if [ -n "$KEYCOMMENT" ]; then
169
 
        KEYCOMMENTLINE="Name-Comment: $KEYCOMMENT"
170
 
    fi
171
 
    if [ -n "$KEYEMAIL" ]; then
172
 
        KEYEMAILLINE="Name-Email: $KEYEMAIL"
173
 
    fi
174
 
 
175
 
    # Create temporary gpg batch file
176
 
    BATCHFILE="`mktemp -t mandos-keygen-batch.XXXXXXXXXX`"
177
 
fi
178
 
 
179
 
if [ "$mode" = password ]; then
180
 
    # Create temporary encrypted password file
181
 
    SECFILE="`mktemp -t mandos-keygen-secfile.XXXXXXXXXX`"
182
 
fi
183
 
 
184
 
# Create temporary key ring directory
185
 
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`"
186
143
 
187
144
# Remove temporary files on exit
188
 
trap "
189
 
set +e; \
190
 
test -n \"$SECFILE\" && shred --remove \"$SECFILE\"; \
191
 
shred --remove \"$RINGDIR\"/sec*;
192
 
test -n \"$BATCHFILE\" && rm --force \"$BATCHFILE\"; \
193
 
rm --recursive --force \"$RINGDIR\";
194
 
stty echo; \
195
 
" EXIT
196
 
 
197
 
umask 077
198
 
 
199
 
if [ "$mode" = keygen ]; then
200
 
    # Create batch file for GnuPG
201
 
    cat >"$BATCHFILE" <<-EOF
202
 
        Key-Type: $KEYTYPE
203
 
        Key-Length: $KEYLENGTH
204
 
        #Key-Usage: encrypt,sign,auth
205
 
        Subkey-Type: $SUBKEYTYPE
206
 
        Subkey-Length: $SUBKEYLENGTH
207
 
        #Subkey-Usage: encrypt,sign,auth
208
 
        Name-Real: $KEYNAME
209
 
        $KEYCOMMENTLINE
210
 
        $KEYEMAILLINE
211
 
        Expire-Date: $KEYEXPIRE
212
 
        #Preferences: <string>
213
 
        #Handle: <no-spaces>
214
 
        #%pubring pubring.gpg
215
 
        #%secring secring.gpg
216
 
        %commit
217
 
        EOF
218
 
    
219
 
    # Generate a new key in the key rings
220
 
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
221
 
        --homedir "$RINGDIR" --trust-model always \
222
 
        --gen-key "$BATCHFILE"
223
 
    rm --force "$BATCHFILE"
224
 
    
225
 
    # Backup any old key files
226
 
    if cp --backup=numbered --force "$SECKEYFILE" "$SECKEYFILE" \
227
 
        2>/dev/null; then
228
 
        shred --remove "$SECKEYFILE"
229
 
    fi
230
 
    if cp --backup=numbered --force "$PUBKEYFILE" "$PUBKEYFILE" \
231
 
        2>/dev/null; then
232
 
        rm --force "$PUBKEYFILE"
233
 
    fi
234
 
    
235
 
    FILECOMMENT="Mandos client key for $KEYNAME"
236
 
    if [ "$KEYCOMMENT" != "$KEYCOMMENT_ORIG" ]; then
237
 
        FILECOMMENT="$FILECOMMENT ($KEYCOMMENT)"
238
 
    fi
239
 
    
240
 
    if [ -n "$KEYEMAIL" ]; then
241
 
        FILECOMMENT="$FILECOMMENT <$KEYEMAIL>"
242
 
    fi
243
 
    
244
 
    # Export key from key rings to key files
245
 
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
246
 
        --homedir "$RINGDIR" --armor --export-options export-minimal \
247
 
        --comment "$FILECOMMENT" --output "$SECKEYFILE" \
248
 
        --export-secret-keys
249
 
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
250
 
        --homedir "$RINGDIR" --armor --export-options export-minimal \
251
 
        --comment "$FILECOMMENT" --output "$PUBKEYFILE" --export
252
 
fi
253
 
 
254
 
if [ "$mode" = password ]; then
255
 
    # Import key into temporary key rings
256
 
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
257
 
        --homedir "$RINGDIR" --trust-model always --armor \
258
 
        --import "$SECKEYFILE"
259
 
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
260
 
        --homedir "$RINGDIR" --trust-model always --armor \
261
 
        --import "$PUBKEYFILE"
262
 
    
263
 
    # Get fingerprint of key
264
 
    FINGERPRINT="`gpg --quiet --batch --no-tty --no-options \
265
 
        --enable-dsa2 --homedir \"$RINGDIR\" --trust-model always \
266
 
        --fingerprint --with-colons \
267
 
        | sed --quiet \
268
 
        --expression='/^fpr:/{s/^fpr:.*:\\([0-9A-Z]*\\):\$/\\1/p;q}'`"
269
 
    
270
 
    test -n "$FINGERPRINT"
271
 
    
272
 
    FILECOMMENT="Encrypted password for a Mandos client"
273
 
    
274
 
    if [ -n "$PASSFILE" ]; then
275
 
        cat "$PASSFILE"
276
 
    else
277
 
        stty -echo
278
 
        echo -n "Enter passphrase: " >&2
279
 
        first="$(head --lines=1 | tr --delete '\n')"
280
 
        echo -n -e "\nRepeat passphrase: " >&2
281
 
        second="$(head --lines=1 | tr --delete '\n')"
282
 
        echo >&2
283
 
        stty echo
284
 
        if [ "$first" != "$second" ]; then
285
 
            echo -e "Passphrase mismatch" >&2
286
 
            false
287
 
        else
288
 
            echo -n "$first"
289
 
        fi
290
 
    fi | gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
291
 
        --homedir "$RINGDIR" --trust-model always --armor --encrypt \
292
 
        --recipient "$FINGERPRINT" --comment "$FILECOMMENT" \
293
 
        > "$SECFILE"
294
 
    status="${PIPESTATUS[0]}"
295
 
    if [ "$status" -ne 0 ]; then
296
 
        exit "$status"
297
 
    fi
298
 
    
299
 
    cat <<-EOF
300
 
        [$KEYNAME]
301
 
        host = $KEYNAME
302
 
        fingerprint = $FINGERPRINT
303
 
        secret =
304
 
        EOF
305
 
    sed --quiet --expression='
306
 
        /^-----BEGIN PGP MESSAGE-----$/,/^-----END PGP MESSAGE-----$/{
307
 
            /^$/,${
308
 
                # Remove 24-bit Radix-64 checksum
309
 
                s/=....$//
310
 
                # Indent four spaces
311
 
                /^[^-]/s/^/    /p
312
 
            }
313
 
        }' < "$SECFILE"
314
 
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
315
200
 
316
201
trap - EXIT
317
202
 
318
 
set +e
319
 
# Remove the password file, if any
320
 
if [ -n "$SECFILE" ]; then
321
 
    shred --remove "$SECFILE"
322
 
fi
323
203
# Remove the key rings
324
 
shred --remove "$RINGDIR"/sec*
325
 
rm --recursive --force "$RINGDIR"
 
204
shred --remove "$SECRING"
 
205
rm --force "$PUBRING"