src/monkeysphere-server

   1 #!/bin/bash
   2
   3 # monkeysphere-server: MonkeySphere server admin tool
   4 #
   5 # The monkeysphere scripts are written by:
   6 # Jameson Rollins <jrollins@fifthhorseman.net>
   7 #
   8 # They are Copyright 2008, and are all released under the GPL, version 3
   9 # or later.
  10
  11 ########################################################################
  12 PGRM=$(basename $0)
  13
  14 SHARE=${MONKEYSPHERE_SHARE:="/usr/share/monkeysphere"}
  15 export SHARE
  16 . "${SHARE}/common" || exit 1
  17
  18 VARLIB="/var/lib/monkeysphere"
  19 export VARLIB
  20
  21 # date in UTF format if needed
  22 DATE=$(date -u '+%FT%T')
  23
  24 # unset some environment variables that could screw things up
  25 unset GREP_OPTIONS
  26
  27 # default return code
  28 RETURN=0
  29
  30 ########################################################################
  31 # FUNCTIONS
  32 ########################################################################
  33
  34 usage() {
  35     cat <<EOF
  36 usage: $PGRM <subcommand> [options] [args]
  37 MonkeySphere server admin tool.
  38
  39 subcommands:
  40  update-users (u) [USER]...          update user authorized_keys files
  41
  42  gen-key (g) [NAME[:PORT]]           generate gpg key for the server
  43    -l|--length BITS                    key length in bits (2048)
  44    -e|--expire EXPIRE                  date to expire
  45    -r|--revoker FINGERPRINT            add a revoker
  46  add-hostname (n+) NAME[:PORT]       add hostname user ID to server key
  47  revoke-hostname (n-) NAME[:PORT]    revoke hostname user ID
  48  show-key (s)                        output all server host key information
  49  fingerprint (f)                     output just the key fingerprint
  50  publish-key (p)                     publish server host key to keyserver
  51  diagnostics (d)                     report on server monkeysphere status
  52
  53  add-id-certifier (c+) KEYID         import and tsign a certification key
  54    -n|--domain DOMAIN                  limit ID certifications to DOMAIN
  55    -t|--trust TRUST                    trust level of certifier (full)
  56    -d|--depth DEPTH                    trust depth for certifier (1)
  57  remove-id-certifier (c-) KEYID      remove a certification key
  58  list-id-certifiers (c)              list certification keys
  59
  60  gpg-authentication-cmd CMD          gnupg-authentication command
  61
  62  -h|--help|help (h,?)                this help
  63 EOF
  64 }
  65
  66 su_monkeysphere_user() {
  67     su --preserve-environment "$MONKEYSPHERE_USER" -- -c "$@"
  68 }
  69
  70 # function to interact with the host gnupg keyring
  71 gpg_host() {
  72     local returnCode
  73
  74     GNUPGHOME="$GNUPGHOME_HOST"
  75     export GNUPGHOME
  76
  77     # NOTE: we supress this warning because we need the monkeysphere
  78     # user to be able to read the host pubring.  we realize this might
  79     # be problematic, but it's the simplest solution, without too much
  80     # loss of security.
  81     gpg --no-permission-warning "$@"
  82     returnCode="$?"
  83
  84     # always reset the permissions on the host pubring so that the
  85     # monkeysphere user can read the trust signatures
  86     chgrp "$MONKEYSPHERE_USER" "${GNUPGHOME_HOST}/pubring.gpg"
  87     chmod g+r "${GNUPGHOME_HOST}/pubring.gpg"
  88
  89     return "$returnCode"
  90 }
  91
  92 # function to interact with the authentication gnupg keyring
  93 # FIXME: this function requires basically accepts only a single
  94 # argument because of problems with quote expansion.  this needs to be
  95 # fixed/improved.
  96 gpg_authentication() {
  97     GNUPGHOME="$GNUPGHOME_AUTHENTICATION"
  98     export GNUPGHOME
  99
 100     su_monkeysphere_user "gpg $@"
 101 }
 102
 103 # output key information
 104 show_server_key() {
 105     gpg_host --list-secret-keys --fingerprint
 106 }
 107
 108 # output just key fingerprint
 109 fingerprint_server_key() {
 110     gpg_host --list-secret-keys --fingerprint --with-colons --fixed-list-mode | \
 111         grep '^fpr:' | head -1 | cut -d: -f10
 112 }
 113
 114 # update authorized_keys for users
 115 update_users() {
 116     if [ "$1" ] ; then
 117         # get users from command line
 118         unames="$@"
 119     else
 120         # or just look at all users if none specified
 121         unames=$(getent passwd | cut -d: -f1)
 122     fi
 123
 124     # set mode
 125     MODE="authorized_keys"
 126
 127     # set gnupg home
 128     GNUPGHOME="$GNUPGHOME_AUTHENTICATION"
 129
 130     # check to see if the gpg trust database has been initialized
 131     if [ ! -s "${GNUPGHOME}/trustdb.gpg" ] ; then
 132         failure "GNUPG trust database uninitialized.  Please see MONKEYSPHERE-SERVER(8)."
 133     fi
 134
 135     # make sure the authorized_keys directory exists
 136     mkdir -p "${VARLIB}/authorized_keys"
 137
 138     # loop over users
 139     for uname in $unames ; do
 140         # check all specified users exist
 141         if ! getent passwd "$uname" >/dev/null ; then
 142             log "----- unknown user '$uname' -----"
 143             continue
 144         fi
 145
 146         # set authorized_user_ids and raw authorized_keys variables,
 147         # translating ssh-style path variables
 148         authorizedUserIDs=$(translate_ssh_variables "$uname" "$AUTHORIZED_USER_IDS")
 149         rawAuthorizedKeys=$(translate_ssh_variables "$uname" "$RAW_AUTHORIZED_KEYS")
 150
 151         # if neither is found, skip user
 152         if [ ! -s "$authorizedUserIDs" ] ; then
 153             if [ "$rawAuthorizedKeys" = '-' -o ! -s "$rawAuthorizedKeys" ] ; then
 154                 continue
 155             fi
 156         fi
 157
 158         log "----- user: $uname -----"
 159
 160         # exit if the authorized_user_ids file is empty
 161         if ! check_key_file_permissions "$uname" "$AUTHORIZED_USER_IDS" ; then
 162             log "Improper permissions on authorized_user_ids file path."
 163             continue
 164         fi
 165
 166         # check permissions on the authorized_keys file path
 167         if ! check_key_file_permissions "$uname" "$RAW_AUTHORIZED_KEYS" ; then
 168             log "Improper permissions on authorized_keys file path path."
 169             continue
 170         fi
 171
 172         # make temporary directory
 173         TMPDIR=$(mktemp -d)
 174
 175         # trap to delete temporary directory on exit
 176         trap "rm -rf $TMPDIR" EXIT
 177
 178         # create temporary authorized_user_ids file
 179         TMP_AUTHORIZED_USER_IDS="${TMPDIR}/authorized_user_ids"
 180         touch "$TMP_AUTHORIZED_USER_IDS"
 181
 182         # create temporary authorized_keys file
 183         AUTHORIZED_KEYS="${TMPDIR}/authorized_keys"
 184         touch "$AUTHORIZED_KEYS"
 185
 186         # set restrictive permissions on the temporary files
 187         # FIXME: is there a better way to do this?
 188         chmod 0700 "$TMPDIR"
 189         chmod 0600 "$AUTHORIZED_KEYS"
 190         chmod 0600 "$TMP_AUTHORIZED_USER_IDS"
 191         chown -R "$MONKEYSPHERE_USER" "$TMPDIR"
 192
 193         # if the authorized_user_ids file exists...
 194         if [ -s "$authorizedUserIDs" ] ; then
 195             # copy user authorized_user_ids file to temporary
 196             # location
 197             cat "$authorizedUserIDs" > "$TMP_AUTHORIZED_USER_IDS"
 198
 199             # export needed variables
 200             export AUTHORIZED_KEYS
 201             export TMP_AUTHORIZED_USER_IDS
 202
 203             # process authorized_user_ids file, as monkeysphere
 204             # user
 205             su_monkeysphere_user \
 206                 ". ${SHARE}/common; process_authorized_user_ids $TMP_AUTHORIZED_USER_IDS"
 207             RETURN="$?"
 208         fi
 209
 210         # add user-controlled authorized_keys file path if specified
 211         if [ "$rawAuthorizedKeys" != '-' -a -s "$rawAuthorizedKeys" ] ; then
 212             log -n "adding raw authorized_keys file... "
 213             cat "$rawAuthorizedKeys" >> "$AUTHORIZED_KEYS"
 214             loge "done."
 215         fi
 216
 217         # openssh appears to check the contents of the
 218         # authorized_keys file as the user in question, so the
 219         # file must be readable by that user at least.
 220         # FIXME: is there a better way to do this?
 221         chown root "$AUTHORIZED_KEYS"
 222         chgrp $(getent passwd "$uname" | cut -f4 -d:) "$AUTHORIZED_KEYS"
 223         chmod g+r "$AUTHORIZED_KEYS"
 224
 225         # move the resulting authorized_keys file into place
 226         mv -f "$AUTHORIZED_KEYS" "${VARLIB}/authorized_keys/${uname}"
 227
 228         # destroy temporary directory
 229         rm -rf "$TMPDIR"
 230     done
 231 }
 232
 233 # generate server gpg key
 234 gen_key() {
 235     local keyType
 236     local keyLength
 237     local keyUsage
 238     local keyExpire
 239     local revoker
 240     local hostName
 241     local userID
 242     local keyParameters
 243     local fingerprint
 244
 245     # set default key parameter values
 246     keyType="RSA"
 247     keyLength="2048"
 248     keyUsage="auth"
 249     keyExpire=
 250     revoker=
 251
 252     # get options
 253     TEMP=$(getopt -o e:l:r -l expire:,length:,revoker: -n "$PGRM" -- "$@")
 254
 255     if [ $? != 0 ] ; then
 256         exit 1
 257     fi
 258
 259     # Note the quotes around `$TEMP': they are essential!
 260     eval set -- "$TEMP"
 261
 262     while true ; do
 263         case "$1" in
 264             -l|--length)
 265                 keyLength="$2"
 266                 shift 2
 267                 ;;
 268             -e|--expire)
 269                 keyExpire="$2"
 270                 shift 2
 271                 ;;
 272             -r|--revoker)
 273                 revoker="$2"
 274                 shift 2
 275                 ;;
 276             --)
 277                 shift
 278                 ;;
 279             *)
 280                 break
 281                 ;;
 282         esac
 283     done
 284
 285     hostName=${1:-$(hostname --fqdn)}
 286     userID="ssh://${hostName}"
 287
 288     # check for presense of key with user ID
 289     if gpg_host --list-key ="$userID" > /dev/null 2>&1 ; then
 290         failure "Key for '$userID' already exists"
 291     fi
 292
 293     # prompt about key expiration if not specified
 294     if [ -z "$keyExpire" ] ; then
 295         cat <<EOF
 296 Please specify how long the key should be valid.
 297          0 = key does not expire
 298       <n>  = key expires in n days
 299       <n>w = key expires in n weeks
 300       <n>m = key expires in n months
 301       <n>y = key expires in n years
 302 EOF
 303         while [ -z "$keyExpire" ] ; do
 304             read -p "Key is valid for? (0) " keyExpire
 305             if ! test_gpg_expire ${keyExpire:=0} ; then
 306                 echo "invalid value"
 307                 unset keyExpire
 308             fi
 309         done
 310     elif ! test_gpg_expire "$keyExpire" ; then
 311         failure "invalid key expiration value '$keyExpire'."
 312     fi
 313
 314     # set key parameters
 315     keyParameters=$(cat <<EOF
 316 Key-Type: $keyType
 317 Key-Length: $keyLength
 318 Key-Usage: $keyUsage
 319 Name-Real: $userID
 320 Expire-Date: $keyExpire
 321 EOF
 322 )
 323
 324     # add the revoker field if specified
 325     # FIXME: the "1:" below assumes that $REVOKER's key is an RSA key.
 326     # FIXME: key is marked "sensitive"?  is this appropriate?
 327     if [ "$revoker" ] ; then
 328         keyParameters="${keyParameters}"$(cat <<EOF
 329 Revoker: 1:$revoker sensitive
 330 EOF
 331 )
 332     fi
 333
 334     echo "The following key parameters will be used for the host private key:"
 335     echo "$keyParameters"
 336
 337     read -p "Generate key? (Y/n) " OK; OK=${OK:=Y}
 338     if [ ${OK/y/Y} != 'Y' ] ; then
 339         failure "aborting."
 340     fi
 341
 342     # add commit command
 343     keyParameters="${keyParameters}"$(cat <<EOF
 344
 345 %commit
 346 %echo done
 347 EOF
 348 )
 349
 350     log "generating server key..."
 351     echo "$keyParameters" | gpg_host --batch --gen-key
 352
 353     # output the server fingerprint
 354     fingerprint_server_key "=${userID}"
 355
 356     # find the key fingerprint of the newly generated key
 357     fingerprint=$(fingerprint_server_key)
 358
 359     # export host ownertrust to authentication keyring
 360     log "setting ultimate owner trust for server key..."
 361     echo "${fingerprint}:6:" | gpg_authentication "--import-ownertrust"
 362
 363     # translate the private key to ssh format, and export to a file
 364     # for sshs usage.
 365     # NOTE: assumes that the primary key is the proper key to use
 366     (umask 077 && \
 367         gpg_host --export-secret-key "$fingerprint" | \
 368         openpgp2ssh "$fingerprint" > "${VARLIB}/ssh_host_rsa_key")
 369     log "Private SSH host key output to file: ${VARLIB}/ssh_host_rsa_key"
 370 }
 371
 372 # add hostname user ID to server key
 373 add_hostname() {
 374     if [ -z "$1" ] ; then
 375         failure "You must specify a hostname to add."
 376     fi
 377
 378     userID="ssh://${1}"
 379
 380     if [ "$(gpg_host --list-key "=${userID}")" ] ; then
 381         failure "Host userID '$userID' already exists."
 382     fi
 383
 384     fingerprint=$(fingerprint_server_key)
 385
 386     adduidCommand=$(cat <<EOF
 387 adduid
 388 $userID
 389
 390
 391 O
 392 save
 393 EOF
 394         )
 395
 396     # add uid
 397     echo "$adduidCommand" | gpg_host --quiet --command-fd 0 --edit-key "$fingerprint"
 398
 399     echo "NOTE: new host userID has not been published."
 400     echo "Use '$PGRM publish-key' to publish these changes."
 401 }
 402
 403 # revoke hostname user ID to server key
 404 revoke_hostname() {
 405     local msg
 406     local uidNum
 407     local tmpuidMatch
 408     local fpr
 409     local linenum
 410
 411     if [ -z "$1" ] ; then
 412         failure "You must specify a hostname to revoke."
 413     fi
 414
 415     fpr=$(fingerprint_server_key)
 416     tmpuidMatch="u:$(escape "$1")"
 417
 418     if linenum=$(gpg_host --list-keys --with-colons --fixed-list-mode "$fpr" | egrep '^(uid|uat):' | cut -f2,10 -d: | grep -n -x -F 'r:Foo T. Bar (DO NOT USE!) <foo@example.net>') ; then
 419         uidNum=${linenum%%:*}
 420     else
 421         failure "no non-revoked hostname '$1' is listed."
 422     fi
 423
 424     msg="hostname removed by monkeysphere-server on $(date +%F)"
 425
 426
 427     revuidCommand=$(cat <<EOF
 428 $uidNum
 429 revuid
 430 y
 431 4
 432 $msg
 433
 434 y
 435 save
 436 EOF
 437 )
 438
 439     echo "$revuidCommand" | gpg_host --quiet --command-fd 0 --edit-key "0x$fingerprint"\!
 440
 441     echo "NOTE: host userID revokation has not been published."
 442     echo "Use '$PGRM publish-key' to publish these changes."
 443 }
 444
 445 # publish server key to keyserver
 446 publish_server_key() {
 447     read -p "Really publish host key to $KEYSERVER? (y/N) " OK; OK=${OK:=N}
 448     if [ ${OK/y/Y} != 'Y' ] ; then
 449         failure "aborting."
 450     fi
 451
 452     # find the key fingerprint
 453     fingerprint=$(fingerprint_server_key)
 454
 455     # publish host key
 456     gpg_authentication "--keyserver $KEYSERVER --send-keys $fingerprint"
 457 }
 458
 459 diagnostics() {
 460 #  * check on the status and validity of the key and public certificates
 461     local seckey
 462     local keysfound
 463     local curdate
 464     local warnwindow
 465     local warndate
 466     local create
 467     local expire
 468     local uid
 469     local fingerprint
 470     local badhostkeys
 471
 472     seckey=$(fingerprint_server_key)
 473     keysfound=$(echo "$seckey" | grep -c ^sec:)
 474     curdate=$(date +%s)
 475     # warn when anything is 2 months away from expiration
 476     warnwindow='2 months'
 477     warndate=$(date +%s -d "$warnwindow")
 478
 479     echo "Checking host GPG key..."
 480     if (( "$keysfound" < 1 )); then
 481         echo "! No host key found."
 482         echo " - Recommendation: run 'monkeysphere-server gen-key'"
 483     elif (( "$keysfound" > 1 )); then
 484         echo "! More than one host key found?"
 485         # FIXME: recommend a way to resolve this
 486     else
 487         create=$(echo "$seckey" | grep ^sec: | cut -f6 -d:)
 488         expire=$(echo "$seckey" | grep ^sec: | cut -f7 -d:)
 489         fingerprint=$(echo "$seckey" | grep ^fpr: | head -n1 | cut -f10 -d:)
 490         # check for key expiration:
 491         if [ "$expire" ]; then
 492             if (( "$expire"  < "$curdate" )); then
 493                 echo "! Host key is expired."
 494                 # FIXME: recommend a way to resolve this other than re-keying?
 495             elif (( "$expire" < "$warndate" )); then
 496                 echo "! Host key expires in less than $warnwindow:" $(date -d "$(( $expire - $curdate )) seconds" +%F)
 497                 # FIXME: recommend a way to resolve this?
 498             fi
 499         fi
 500
 501         # and weirdnesses:
 502         if [ "$create" ] && (( "$create" > "$curdate" )); then
 503             echo "! Host key was created in the future(?!). Is your clock correct?"
 504             echo " - Recommendation: Check clock ($(date +%F_%T)); use NTP?"
 505         fi
 506
 507         # check for UserID expiration:
 508         echo "$seckey" | grep ^uid: | cut -d: -f6,7,10 | \
 509         while IFS=: read create expire uid ; do
 510             # FIXME: should we be doing any checking on the form
 511             # of the User ID?  Should we be unmangling it somehow?
 512
 513             if [ "$create" ] && (( "$create" > "$curdate" )); then
 514                 echo "! User ID '$uid' was created in the future(?!).  Is your clock correct?"
 515                 echo " - Recommendation: Check clock ($(date +%F_%T)); use NTP?"
 516             fi
 517             if [ "$expire" ] ; then
 518                 if (( "$expire" < "$curdate" )); then
 519                     echo "! User ID '$uid' is expired."
 520                         # FIXME: recommend a way to resolve this
 521                 elif (( "$expire" < "$warndate" )); then
 522                     echo "! User ID '$uid' expires in less than $warnwindow:" $(date -d "$(( $expire - $curdate )) seconds" +%F)
 523                     # FIXME: recommend a way to resolve this
 524                 fi
 525             fi
 526         done
 527
 528 # FIXME: verify that the host key is properly published to the
 529 #   keyservers (do this with the non-privileged user)
 530
 531 # FIXME: check that there are valid, non-expired certifying signatures
 532 #   attached to the host key after fetching from the public keyserver
 533 #   (do this with the non-privileged user as well)
 534
 535 # FIXME: propose adding a revoker to the host key if none exist (do we
 536 #   have a way to do that after key generation?)
 537
 538         # Ensure that the ssh_host_rsa_key file is present and non-empty:
 539         echo "Checking host SSH key..."
 540         if [ ! -s "${VARLIB}/ssh_host_rsa_key" ] ; then
 541             echo "! The host key as prepared for SSH (${VARLIB}/ssh_host_rsa_key) is missing or empty."
 542         else
 543             if [ $(stat -c '%a' "${VARLIB}/ssh_host_rsa_key") != 600 ] ; then
 544                 echo "! Permissions seem wrong for ${VARLIB}/ssh_host_rsa_key -- should be 0600."
 545             fi
 546
 547             # propose changes needed for sshd_config (if any)
 548             if ! grep -q "^HostKey[[:space:]]\+${VARLIB}/ssh_host_rsa_key$" /etc/ssh/sshd_config; then
 549                 echo "! /etc/ssh/sshd_config does not point to the monkeysphere host key (${VARLIB}/ssh_host_rsa_key)."
 550                 echo " - Recommendation: add a line to /etc/ssh/sshd_config: 'HostKey ${VARLIB}/ssh_host_rsa_key'"
 551             fi
 552             if badhostkeys=$(grep -i '^HostKey' | grep -q -v "^HostKey[[:space:]]\+${VARLIB}/ssh_host_rsa_key$") ; then
 553                 echo "! /etc/sshd_config refers to some non-monkeysphere host keys:"
 554                 echo "$badhostkeys"
 555                 echo " - Recommendation: remove the above HostKey lines from /etc/ssh/sshd_config"
 556             fi
 557         fi
 558     fi
 559
 560 # FIXME: look at the ownership/privileges of the various keyrings,
 561 #    directories housing them, etc (what should those values be?  can
 562 #    we make them as minimal as possible?)
 563
 564 # FIXME: look to see that the ownertrust rules are set properly on the
 565 #    authentication keyring
 566
 567 # FIXME:  make sure that at least one identity certifier exists
 568
 569     echo "Checking for MonkeySphere-enabled public-key authentication for users ..."
 570     # Ensure that User ID authentication is enabled:
 571     if ! grep -q "^AuthorizedKeysFile[[:space:]]\+${VARLIB}/authorized_keys/%u$" /etc/ssh/sshd_config; then
 572         echo "! /etc/ssh/sshd_config does not point to monkeysphere authorized keys."
 573         echo " - Recommendation: add a line to /etc/ssh/sshd_config: 'AuthorizedKeysFile ${VARLIB}/authorized_keys/%u'"
 574     fi
 575     if badauthorizedkeys=$(grep -i '^AuthorizedKeysFile' | grep -q -v "^AuthorizedKeysFile[[:space:]]\+${VARLIB}/authorized_keys/%u$") ; then
 576         echo "! /etc/sshd_config refers to non-monkeysphere authorized_keys files:"
 577         echo "$badauthorizedkeys"
 578         echo " - Recommendation: remove the above AuthorizedKeysFile lines from /etc/ssh/sshd_config"
 579     fi
 580 }
 581
 582 # retrieve key from web of trust, import it into the host keyring, and
 583 # ltsign the key in the host keyring so that it may certify other keys
 584 add_certifier() {
 585     local domain
 586     local trust
 587     local depth
 588     local keyID
 589     local fingerprint
 590     local ltsignCommand
 591     local trustval
 592
 593     # set default values for trust depth and domain
 594     domain=
 595     trust=full
 596     depth=1
 597
 598     # get options
 599     TEMP=$(getopt -o n:t:d: -l domain:,trust:,depth: -n "$PGRM" -- "$@")
 600
 601     if [ $? != 0 ] ; then
 602         exit 1
 603     fi
 604
 605     # Note the quotes around `$TEMP': they are essential!
 606     eval set -- "$TEMP"
 607
 608     while true ; do
 609         case "$1" in
 610             -n|--domain)
 611                 domain="$2"
 612                 shift 2
 613                 ;;
 614             -t|--trust)
 615                 trust="$2"
 616                 shift 2
 617                 ;;
 618             -d|--depth)
 619                 depth="$2"
 620                 shift 2
 621                 ;;
 622             --)
 623                 shift
 624                 ;;
 625             *)
 626                 break
 627                 ;;
 628         esac
 629     done
 630
 631     keyID="$1"
 632     if [ -z "$keyID" ] ; then
 633         failure "You must specify the key ID of a key to add."
 634     fi
 635     export keyID
 636
 637     # get the key from the key server
 638     gpg_authentication "--keyserver $KEYSERVER --recv-key '$keyID'"
 639
 640     # get the full fingerprint of a key ID
 641     fingerprint=$(gpg_authentication "--list-key --with-colons --with-fingerprint $keyID" | \
 642         grep '^fpr:' | grep "$keyID" | cut -d: -f10)
 643
 644     echo "key found:"
 645     gpg_authentication "--fingerprint $fingerprint"
 646
 647     echo "Are you sure you want to add this key as a certifier of"
 648     read -p "users on this system? (y/N) " OK; OK=${OK:-N}
 649     if [ "${OK/y/Y}" != 'Y' ] ; then
 650         failure "aborting."
 651     fi
 652
 653     # export the key to the host keyring
 654     gpg_authentication "--export $keyID" | gpg_host --import
 655
 656     if [ "$trust" == marginal ]; then
 657         trustval=1
 658     elif [ "$trust" == full ]; then
 659         trustval=2
 660     else
 661         failure "trust value requested ('$trust') was unclear (only 'marginal' or 'full' are supported)"
 662     fi
 663
 664     # ltsign command
 665     # NOTE: *all* user IDs will be ltsigned
 666     ltsignCommand=$(cat <<EOF
 667 ltsign
 668 y
 669 $trustval
 670 $depth
 671 $domain
 672 y
 673 save
 674 EOF
 675         )
 676
 677     # ltsign the key
 678     echo "$ltsignCommand" | gpg_host --quiet --command-fd 0 --edit-key "$fingerprint"
 679
 680     # update the trustdb for the authentication keyring
 681     gpg_authentication "--check-trustdb"
 682 }
 683
 684 # delete a certifiers key from the host keyring
 685 remove_certifier() {
 686     local keyID
 687     local fingerprint
 688
 689     keyID="$1"
 690     if [ -z "$keyID" ] ; then
 691         failure "You must specify the key ID of a key to remove."
 692     fi
 693
 694     # delete the requested key (with prompting)
 695     gpg_host --delete-key "$keyID"
 696
 697     # update the trustdb for the authentication keyring
 698     gpg_authentication "--check-trustdb"
 699 }
 700
 701 # list the host certifiers
 702 list_certifiers() {
 703     gpg_host --list-keys
 704 }
 705
 706 # issue command to gpg-authentication keyring
 707 gpg_authentication_cmd() {
 708     gpg_authentication "$@"
 709 }
 710
 711 ########################################################################
 712 # MAIN
 713 ########################################################################
 714
 715 # unset variables that should be defined only in config file
 716 unset KEYSERVER
 717 unset AUTHORIZED_USER_IDS
 718 unset RAW_AUTHORIZED_KEYS
 719 unset MONKEYSPHERE_USER
 720
 721 # load configuration file
 722 [ -e ${MONKEYSPHERE_SERVER_CONFIG:="${ETC}/monkeysphere-server.conf"} ] && . "$MONKEYSPHERE_SERVER_CONFIG"
 723
 724 # set empty config variable with ones from the environment, or with
 725 # defaults
 726 KEYSERVER=${MONKEYSPHERE_KEYSERVER:=${KEYSERVER:="subkeys.pgp.net"}}
 727 AUTHORIZED_USER_IDS=${MONKEYSPHERE_AUTHORIZED_USER_IDS:=${AUTHORIZED_USER_IDS:="%h/.config/monkeysphere/authorized_user_ids"}}
 728 RAW_AUTHORIZED_KEYS=${MONKEYSPHERE_RAW_AUTHORIZED_KEYS:=${RAW_AUTHORIZED_KEYS:="%h/.ssh/authorized_keys"}}
 729 MONKEYSPHERE_USER=${MONKEYSPHERE_MONKEYSPHERE_USER:=${MONKEYSPHERE_USER:="monkeysphere"}}
 730
 731 # other variables
 732 CHECK_KEYSERVER=${MONKEYSPHERE_CHECK_KEYSERVER:="true"}
 733 REQUIRED_USER_KEY_CAPABILITY=${MONKEYSPHERE_REQUIRED_USER_KEY_CAPABILITY:="a"}
 734 GNUPGHOME_HOST=${MONKEYSPHERE_GNUPGHOME_HOST:="${VARLIB}/gnupg-host"}
 735 GNUPGHOME_AUTHENTICATION=${MONKEYSPHERE_GNUPGHOME_AUTHENTICATION:="${VARLIB}/gnupg-authentication"}
 736
 737 # export variables needed in su invocation
 738 export DATE
 739 export MODE
 740 export MONKEYSPHERE_USER
 741 export KEYSERVER
 742 export CHECK_KEYSERVER
 743 export REQUIRED_USER_KEY_CAPABILITY
 744 export GNUPGHOME_HOST
 745 export GNUPGHOME_AUTHENTICATION
 746 export GNUPGHOME
 747
 748 # get subcommand
 749 COMMAND="$1"
 750 [ "$COMMAND" ] || failure "Type '$PGRM help' for usage."
 751 shift
 752
 753 case $COMMAND in
 754     'update-users'|'update-user'|'u')
 755         update_users "$@"
 756         ;;
 757
 758     'gen-key'|'g')
 759         gen_key "$@"
 760         ;;
 761
 762     'add-hostname'|'add-name'|'n+')
 763         add_hostname "$@"
 764         ;;
 765
 766     'revoke-hostname'|'revoke-name'|'n-')
 767         revoke_hostname "$@"
 768         ;;
 769
 770     'show-key'|'show'|'s')
 771         show_server_key
 772         ;;
 773
 774     'show-fingerprint'|'fingerprint'|'f')
 775         fingerprint_server_key
 776         ;;
 777
 778     'publish-key'|'publish'|'p')
 779         publish_server_key
 780         ;;
 781
 782     'diagnostics'|'d')
 783         diagnostics
 784         ;;
 785
 786     'add-identity-certifier'|'add-id-certifier'|'add-certifier'|'c+')
 787         add_certifier "$@"
 788         ;;
 789
 790     'remove-identity-certifier'|'remove-id-certifier'|'remove-certifier'|'c-')
 791         remove_certifier "$@"
 792         ;;
 793
 794     'list-identity-certifiers'|'list-id-certifiers'|'list-certifiers'|'list-certifier'|'c')
 795         list_certifiers "$@"
 796         ;;
 797
 798     'gpg-authentication-cmd')
 799         gpg_authentication_cmd "$@"
 800         ;;
 801
 802     '--help'|'help'|'-h'|'h'|'?')
 803         usage
 804         ;;
 805
 806     *)
 807         failure "Unknown command: '$COMMAND'
 808 Type '$PGRM help' for usage."
 809         ;;
 810 esac
 811
 812 exit "$RETURN"