Return to ssl_init.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / libntp

Annotation of embedaddon/ntp/libntp/ssl_init.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * ssl_init.c  Common OpenSSL initialization code for the various
                      3:  *             programs which use it.
                      4:  *
                      5:  * Moved from ntpd/ntp_crypto.c crypto_setup()
                      6:  */
                      7: #ifdef HAVE_CONFIG_H
                      8: #include <config.h>
                      9: #endif
                     10: #include <ctype.h>
                     11: #include <ntp.h>
                     12: #include <ntp_debug.h>
                     13: #include <lib_strbuf.h>
                     14: 
                     15: #ifdef OPENSSL
                     16: #include "openssl/err.h"
                     17: #include "openssl/evp.h"
                     18: 
                     19: 
                     20: int ssl_init_done;
                     21: 
                     22: void
                     23: ssl_init(void)
                     24: {
                     25:        if (ssl_init_done)
                     26:                return;
                     27: 
                     28:        ERR_load_crypto_strings();
                     29:        OpenSSL_add_all_algorithms();
                     30: 
                     31:        ssl_init_done = 1;
                     32: }
                     33: 
                     34: 
                     35: void
                     36: ssl_check_version(void)
                     37: {
                     38:        if ((SSLeay() ^ OPENSSL_VERSION_NUMBER) & ~0xff0L) {
                     39:                msyslog(LOG_WARNING,
                     40:                    "OpenSSL version mismatch. Built against %lx, you have %lx",
                     41:                    OPENSSL_VERSION_NUMBER, SSLeay());
                     42:                fprintf(stderr,
                     43:                    "OpenSSL version mismatch. Built against %lx, you have %lx\n",
                     44:                    OPENSSL_VERSION_NUMBER, SSLeay());
                     45:        }
                     46: 
                     47:        INIT_SSL();
                     48: }
                     49: #endif /* OPENSSL */
                     50: 
                     51: 
                     52: /*
                     53:  * keytype_from_text   returns OpenSSL NID for digest by name, and
                     54:  *                     optionally the associated digest length.
                     55:  *
                     56:  * Used by ntpd authreadkeys(), ntpq and ntpdc keytype()
                     57:  */
                     58: int
                     59: keytype_from_text(
                     60:        const char *text,
                     61:        size_t *pdigest_len
                     62:        )
                     63: {
                     64:        const u_long    max_digest_len = MAX_MAC_LEN - sizeof(keyid_t);
                     65:        int             key_type;
                     66:        u_int           digest_len;
                     67: #ifdef OPENSSL
                     68:        u_char          digest[EVP_MAX_MD_SIZE];
                     69:        char *          upcased;
                     70:        char *          pch;
                     71:        EVP_MD_CTX      ctx;
                     72: 
                     73:        /*
                     74:         * OpenSSL digest short names are capitalized, so uppercase the
                     75:         * digest name before passing to OBJ_sn2nid().  If it is not
                     76:         * recognized but begins with 'M' use NID_md5 to be consistent
                     77:         * with past behavior.
                     78:         */
                     79:        INIT_SSL();
                     80:        LIB_GETBUF(upcased);
                     81:        strncpy(upcased, text, LIB_BUFLENGTH);
                     82:        for (pch = upcased; '\0' != *pch; pch++)
                     83:                *pch = (char)toupper(*pch);
                     84:        key_type = OBJ_sn2nid(upcased);
                     85: #else
                     86:        key_type = 0;
                     87: #endif
                     88: 
                     89:        if (!key_type && 'm' == tolower(text[0]))
                     90:                key_type = NID_md5;
                     91: 
                     92:        if (!key_type)
                     93:                return 0;
                     94: 
                     95:        if (NULL != pdigest_len) {
                     96: #ifdef OPENSSL
                     97:                EVP_DigestInit(&ctx, EVP_get_digestbynid(key_type));
                     98:                EVP_DigestFinal(&ctx, digest, &digest_len);
                     99:                if (digest_len + sizeof(keyid_t) > MAX_MAC_LEN) {
                    100:                        fprintf(stderr,
                    101:                                "key type %s %u octet digests are too big, max %lu\n",
                    102:                                keytype_name(key_type), digest_len,
                    103:                                max_digest_len);
                    104:                        msyslog(LOG_ERR,
                    105:                                "key type %s %u octet digests are too big, max %lu\n",
                    106:                                keytype_name(key_type), digest_len,
                    107:                                max_digest_len);
                    108:                        return 0;
                    109:                }
                    110: #else
                    111:                digest_len = 16;
                    112: #endif
                    113:                *pdigest_len = digest_len;
                    114:        }
                    115: 
                    116:        return key_type;
                    117: }
                    118: 
                    119: 
                    120: /*
                    121:  * keytype_name                returns OpenSSL short name for digest by NID.
                    122:  *
                    123:  * Used by ntpq and ntpdc keytype()
                    124:  */
                    125: const char *
                    126: keytype_name(
                    127:        int nid
                    128:        )
                    129: {
                    130:        static const char unknown_type[] = "(unknown key type)";
                    131:        const char *name;
                    132: 
                    133: #ifdef OPENSSL
                    134:        INIT_SSL();
                    135:        name = OBJ_nid2sn(nid);
                    136:        if (NULL == name)
                    137:                name = unknown_type;
                    138: #else  /* !OPENSSL follows */
                    139:        if (NID_md5 == nid)
                    140:                name = "MD5";
                    141:        else
                    142:                name = unknown_type;
                    143: #endif
                    144:        return name;
                    145: }
                    146: 
                    147: 
                    148: /*
                    149:  * Use getpassphrase() if configure.ac detected it, as Suns that
                    150:  * have it truncate the password in getpass() to 8 characters.
                    151:  */
                    152: #ifdef HAVE_GETPASSPHRASE
                    153: # define       getpass(str)    getpassphrase(str)
                    154: #endif
                    155: 
                    156: /*
                    157:  * getpass_keytype() -- shared between ntpq and ntpdc, only vaguely
                    158:  *                     related to the rest of ssl_init.c.
                    159:  */
                    160: char *
                    161: getpass_keytype(
                    162:        int     keytype
                    163:        )
                    164: {
                    165:        char    pass_prompt[64 + 11 + 1]; /* 11 for " Password: " */
                    166: 
                    167:        snprintf(pass_prompt, sizeof(pass_prompt),
                    168:                 "%.64s Password: ", keytype_name(keytype));
                    169: 
                    170:        return getpass(pass_prompt);
                    171: }