Changeset 626 in openpam


Ignore:
Timestamp:
Feb 27, 2013, 4:19:56 PM (8 years ago)
Author:
Dag-Erling Smørgrav
Message:

Implement otpauth URI parsing (untested)

Location:
trunk/modules/pam_oath
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/modules/pam_oath/Makefile.am

    r623 r626  
    22
    33pkglibdir = @OPENPAM_MODULES_DIR@
    4 AM_CPPFLAGS = -I$(top_srcdir)/include
     4AM_CPPFLAGS = -I$(top_srcdir)/include -I$(top_srcdir)/lib
    55
    66if WITH_PAM_OATH
     7noinst_HEADERS = oath.h
     8
    79pkglib_LTLIBRARIES = pam_oath.la
    8 
    9 noinst_HEADERS = oath.h
    10 pam_oath_la_SOURCES = pam_oath.c oath_hotp.c oath_totp.c
     10pam_oath_la_SOURCES = pam_oath.c
     11pam_oath_la_SOURCES += oath_base32.c oath_base64.c
     12pam_oath_la_SOURCES += oath_hotp.c oath_totp.c
     13pam_oath_la_SOURCES += oath_key.c
    1114pam_oath_la_LDFLAGS = -no-undefined -module -version-info @LIB_MAJ@ \
    1215        -export-symbols-regex '^pam_sm_'
    1316pam_oath_la_LIBADD = $(top_builddir)/lib/libpam.la @CRYPTO_LIBS@
     17
    1418endif
  • trunk/modules/pam_oath/oath.h

    r623 r626  
    3333#define OATH_H_INCLUDED
    3434
    35 #define base32_enclen(l) (((l + 4) / 5) * 8)
    36 #define base32_declen(l) (((l + 7) / 8) * 5)
     35/*
     36 * Maximum time step for TOTP: 10 minutes, which RFC 6238 cites as an
     37 * example of an unreasonably large time step.
     38 */
     39#define OATH_MAX_TIMESTEP       600
     40
     41/*
     42 * Maximum key length in bytes.  HMAC has a 64-byte block size; if the key
     43 * K is longer than that, HMAC derives a new key K' = H(K).
     44 */
     45#define OATH_MAX_KEYLEN         64
     46
     47/* estimate of output length for base32 encoding / decoding */
     48#define base32_enclen(l) (size_t)(((l + 4) / 5) * 8)
     49#define base32_declen(l) (size_t)(((l + 7) / 8) * 5)
     50
     51/* base32 encoding / decoding */
    3752int base32_enc(const uint8_t *, size_t, char *, size_t *);
    3853int base32_dec(const char *, size_t, uint8_t *, size_t *);
    3954
    40 #define base64_enclen(l) (((l + 2) / 3) * 4)
    41 #define base64_declen(l) (((l + 3) / 4) * 3)
     55/* estimate of output length for base64 encoding / decoding */
     56#define base64_enclen(l) (size_t)(((l + 2) / 3) * 4)
     57#define base64_declen(l) (size_t)(((l + 3) / 4) * 3)
     58
     59/* base64 encoding / decoding */
    4260int base64_enc(const uint8_t *, size_t, char *, size_t *);
    4361int base64_dec(const char *, size_t, uint8_t *, size_t *);
    4462
    45 enum oath_alg { undef, hotp, totp };
     63/* mode: hotp (event mode) or totp (time-synch mode) */
     64enum oath_mode { om_undef, om_hotp, om_totp };
    4665
    47 struct oath {
    48         enum oath_alg    alg;
    49         unsigned int     seq;
    50         size_t           keylen;
    51         uint8_t          key[];
     66/* hash function */
     67enum oath_hash { oh_undef, oh_sha1, oh_sha256, oh_sha512, oh_md5 };
     68
     69/* key structure */
     70struct oath_key {
     71        /* mode and parameters */
     72        enum oath_mode   mode;
     73        unsigned int     digits;
     74        uint64_t         counter;
     75        unsigned int     timestep; /* in seconds */
     76
     77        /* hash algorithm */
     78        enum oath_hash   hash;
     79
     80        /* label */
     81        size_t           labellen; /* bytes incl. NUL */
     82        char            *label;
     83
     84        /* key */
     85        size_t           keylen; /* bytes */
     86        uint8_t         *key;
     87
     88        /* buffer for label + NUL + key */
     89        size_t           datalen; /* bytes */
     90        uint8_t          data[];
    5291};
    5392
  • trunk/modules/pam_oath/oath_base32.c

    r623 r626  
    3434#endif
    3535
     36#include <sys/types.h>
     37
    3638#include <errno.h>
    3739#include <stdint.h>
     
    3941#include "oath.h"
    4042
    41 static const char b32 =
     43static const char b32[] =
    4244    "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
    4345
  • trunk/modules/pam_oath/oath_base64.c

    r623 r626  
    3434#endif
    3535
     36#include <sys/types.h>
     37
    3638#include <errno.h>
    3739#include <stdint.h>
     
    3941#include "oath.h"
    4042
    41 static const char b64 =
     43static const char b64[] =
    4244    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    4345    "abcdefghijklmnopqrstuvwxyz"
  • trunk/modules/pam_oath/oath_key.c

    r623 r626  
    3434#endif
    3535
     36#include <sys/types.h>
     37
    3638#include <errno.h>
     39#include <inttypes.h>
     40#include <limits.h>
    3741#include <stdint.h>
     42#include <stdio.h>
     43#include <stdlib.h>
     44#include <string.h>
     45
     46#include <security/pam_appl.h>
     47#include <security/openpam.h>
     48#include "openpam_strlcmp.h"
    3849
    3950#include "oath.h"
    4051
    41 /* amount of space necessary to store base32-encoded data */
    42 #define base32_enclen(l) (((l + 4) / 5) * 8)
    43 
    44 /* maximum decoded length of base32-encoded data */
    45 #define base32_declen(l) (((l + 7) / 8) * 5)
    46 
    47 static const char b32 =
    48     "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
    49 
    5052/*
    51  * Encode data in RFC 3548 base 32 representation.  The target buffer must
    52  * have room for base32_enclen(len) characters and a terminating NUL.
    53  */
    54 static int
    55 base32_enc(const uint8_t *in, size_t ilen, char *out, size_t *olen)
    56 {
    57         uint64_t bits;
    58 
    59         if (*olen <= base32_enclen(ilen))
    60                 return (-1);
    61         *olen = 0;
    62         while (ilen >= 5) {
    63                 bits = 0;
    64                 bits = bits << 8 | in[0];
    65                 bits = bits << 8 | in[1];
    66                 bits = bits << 8 | in[2];
    67                 bits = bits << 8 | in[3];
    68                 bits = bits << 8 | in[4];
    69                 ilen -= 5;
    70                 in += 5;
    71                 out[0] = b32[bits >> 5*7 & 0x1f];
    72                 out[1] = b32[bits >> 5*6 & 0x1f];
    73                 out[2] = b32[bits >> 5*5 & 0x1f];
    74                 out[3] = b32[bits >> 5*4 & 0x1f];
    75                 out[4] = b32[bits >> 5*3 & 0x1f];
    76                 out[5] = b32[bits >> 5*2 & 0x1f];
    77                 out[6] = b32[bits >> 5*1 & 0x1f];
    78                 out[7] = b32[bits >> 5*0 & 0x1f];
    79                 olen += 8;
    80                 out += 8;
    81         }
    82         if (ilen > 0) {
    83                 bits = 0;
    84                 switch (ilen) {
    85                 case 4:
    86                         bits |= (uint64_t)in[3] << 8;
    87                 case 3:
    88                         bits |= (uint64_t)in[2] << 16;
    89                 case 2:
    90                         bits |= (uint64_t)in[1] << 24;
    91                 case 1:
    92                         bits |= (uint64_t)in[1] << 32;
     53 * Allocate a struct oath_key with sufficient additional space for the
     54 * label and key.
     55 */
     56struct oath_key *
     57oath_key_alloc(size_t extra)
     58{
     59        struct oath_key *key;
     60
     61        if ((key = calloc(1, sizeof *key + extra)) == NULL) {
     62                openpam_log(PAM_LOG_ERROR, "malloc(): %s", strerror(errno));
     63                return (NULL);
     64        }
     65        key->datalen = extra;
     66        /* XXX should try to wire */
     67        return (key);
     68}
     69
     70/*
     71 * Wipe and free a struct oath_key
     72 */
     73void
     74oath_key_free(struct oath_key *key)
     75{
     76
     77        if (key != NULL) {
     78                memset(key, 0, sizeof *key + key->datalen);
     79                free(key);
     80        }
     81}
     82
     83/*
     84 * Allocate a struct oath_key and populate it from a Google Authenticator
     85 * otpauth URI
     86 */
     87struct oath_key *
     88oath_key_from_uri(const char *uri)
     89{
     90        struct oath_key *key;
     91        const char *p, *q, *r;
     92        uintmax_t n;
     93        char *e;
     94
     95        /*
     96         * The URI string contains the label, the base32-encoded key and
     97         * some fluff, so the combined length of the label and key can
     98         * never exceed the length of the URI string.
     99         */
     100        if ((key = oath_key_alloc(strlen(uri))) == NULL)
     101                return (NULL);
     102
     103        /* check method */
     104        p = uri;
     105        if (strlcmp("otpauth://", p, 10) != 0)
     106                goto invalid;
     107        p += 10;
     108
     109        /* check mode (hotp = event, totp = time-sync) */
     110        if ((q = strchr(p, '/')) == NULL)
     111                goto invalid;
     112        if (strlcmp("hotp", p, q - p) == 0) {
     113                openpam_log(PAM_LOG_DEBUG, "OATH mode: HOTP");
     114                key->mode = om_hotp;
     115        } else if (strlcmp("totp", p, q - p) == 0) {
     116                openpam_log(PAM_LOG_DEBUG, "OATH mode: TOTP");
     117                key->mode = om_totp;
     118        } else {
     119                goto invalid;
     120        }
     121        p = q + 1;
     122
     123        /* extract label */
     124        if ((q = strchr(p, '?')) == NULL)
     125                goto invalid;
     126        key->label = (char *)key->data;
     127        key->labellen = (q - p) + 1;
     128        /* assert: key->labellen < key->datalen */
     129        memcpy(key->label, p, q - p);
     130        key->label[q - p] = '\0';
     131        p = q + 1;
     132
     133        /* extract parameters */
     134        key->counter = UINTMAX_MAX;
     135        while (*p != '\0') {
     136                if ((q = strchr(p, '=')) == NULL)
     137                        goto invalid;
     138                q = q + 1;
     139                if ((r = strchr(p, '&')) == NULL)
     140                        r = strchr(p, '\0');
     141                if (r < q)
     142                        /* & before = */
     143                        goto invalid;
     144                /* p points to key, q points to value, r points to & or NUL */
     145                if (strlcmp("secret=", p, q - p) == 0) {
     146                        if (key->keylen != 0)
     147                                /* dupe */
     148                                goto invalid;
     149                        /* base32-encoded key - multiple of 40 bits */
     150                        if ((r - q) % 8 != 0 ||
     151                            base32_declen(r - q) > OATH_MAX_KEYLEN)
     152                                goto invalid;
     153                        key->key = key->data + key->labellen;
     154                        if (base32_dec(q, r - q, key->key, &key->keylen) != 0)
     155                                goto invalid;
     156                        if (base32_enclen(key->keylen) != (size_t)(r - q))
     157                                goto invalid;
     158                } else if (strlcmp("algorithm=", p, q - p) == 0) {
     159                        if (key->hash != oh_undef)
     160                                /* dupe */
     161                                goto invalid;
     162                        if (strlcmp("SHA1", q, r - q) == 0)
     163                                key->hash = oh_sha1;
     164                        else if (strlcmp("SHA256", q, r - q) == 0)
     165                                key->hash = oh_sha256;
     166                        else if (strlcmp("SHA512", q, r - q) == 0)
     167                                key->hash = oh_sha512;
     168                        else if (strlcmp("MD5", q, r - q) == 0)
     169                                key->hash = oh_md5;
     170                        else
     171                                goto invalid;
     172                } else if (strlcmp("digits=", p, q - p) == 0) {
     173                        if (key->digits != 0)
     174                                /* dupe */
     175                                goto invalid;
     176                        /* only 6 or 8 */
     177                        if (r - q != 1 || (*q != '6' && *q != '8'))
     178                                goto invalid;
     179                        key->digits = *q - '0';
     180                } else if (strlcmp("counter=", p, q - p) == 0) {
     181                        if (key->counter != UINTMAX_MAX)
     182                                /* dupe */
     183                                goto invalid;
     184                        n = strtoumax(q, &e, 10);
     185                        if (e != r || n >= UINTMAX_MAX)
     186                                goto invalid;
     187                        key->counter = (uint64_t)n;
     188                } else if (strlcmp("period=", p, q - p) == 0) {
     189                        if (key->timestep != 0)
     190                                /* dupe */
     191                                goto invalid;
     192                        n = strtoumax(q, &e, 10);
     193                        if (e != r || n > OATH_MAX_TIMESTEP)
     194                                goto invalid;
     195                        key->timestep = n;
     196                } else {
     197                        goto invalid;
    93198                }
    94                 out[0] = b32[bits >> 5*7 & 0x1f];
    95                 out[1] = b32[bits >> 5*6 & 0x1f];
    96                 out[2] = ilen > 1 ? b32[bits >> 5*5 & 0x1f] : '=';
    97                 out[3] = ilen > 1 ? b32[bits >> 5*4 & 0x1f] : '=';
    98                 out[4] = ilen > 2 ? b32[bits >> 5*3 & 0x1f] : '=';
    99                 out[5] = ilen > 3 ? b32[bits >> 5*2 & 0x1f] : '=';
    100                 out[6] = ilen > 3 ? b32[bits >> 5*1 & 0x1f] : '=';
    101                 out[7] = '=';
    102                 olen += 8;
    103                 out += 8;
    104         }
    105         out[0] = '\0';
    106         return (0);
    107 }
    108 
    109 /*
    110  * Decode data in RFC 2548 base 32 representation, stopping at the
    111  * terminating NUL, the first invalid (non-base32, non-whitespace)
    112  * character or after len characters, whichever comes first.
    113  *
    114  * The olen argument is used by the caller to pass the size of the buffer
    115  * and by base32_dec() to return the amount of data successfully decoded.
    116  * If the buffer is too small, base32_dec() discards the excess data, but
    117  * returns the total amount.
    118  */
    119 static int
    120 base32_dec(const char *in, size_t ilen, uint8_t *out, size_t *olen)
    121 {
     199                /* final parameter? */
     200                if (*r == '\0')
     201                        break;
     202                /* skip & and continue */
     203                p = r + 1;
     204        }
     205
     206invalid:
     207        openpam_log(PAM_LOG_NOTICE, "invalid OATH URI: %s", uri);
     208        oath_key_free(key);
     209        return (NULL);
     210}
     211
     212struct oath_key *
     213oath_key_from_file(const char *filename)
     214{
     215        struct oath_key *key;
     216        FILE *f;
     217        char *line;
    122218        size_t len;
    123         uint64_t bits;
    124         int shift;
    125 
    126         for (len = 0, bits = 0, shift = 40; ilen && *in; --ilen, ++in) {
    127                 if (*in == ' ' || *in == '\t' || *in == '\r' || *in == '\n') {
    128                         continue;
    129                 } else if (*in >= 'A' && *in <= 'Z') {
    130                         shift -= 5;
    131                         bits |= (uint64_t)(*in - 'A') << shift;
    132                 } else if (*in >= 'a' && *in <= 'z') {
    133                         shift -= 5;
    134                         bits |= (uint64_t)(*in - 'a') << shift;
    135                 } else if (*in >= '2' && *in <= '7') { 
    136                         shift -= 5;
    137                         bits |= (uint64_t)(*in - '2' + 26) << shift;
    138                 } else {
    139                         *olen = 0;
    140                         return (-1);
    141                 }
    142                 if (shift == 0) {
    143                         if ((len += 5) <= *olen) {
    144                                 out[0] = (bits >> 32) & 0xff;
    145                                 out[1] = (bits >> 24) & 0xff;
    146                                 out[2] = (bits >> 16) & 0xff;
    147                                 out[3] = (bits >> 8) & 0xff;
    148                                 out[4] = bits & 0xff;
    149                                 out += 5;
    150                         }
    151                         bits = 0;
    152                         shift = 40;
    153                 }
    154         }
    155         if (len > *olen) {
    156                 *olen = len;
    157                 return (-1);
    158         }
    159         *olen = len;
    160         return (0);
    161 }
     219
     220        if ((f = fopen(filename, "r")) == NULL)
     221                return (NULL);
     222        /* get first non-empty non-comment line */
     223        line = openpam_readline(f, NULL, &len);
     224        if (strlcmp("otpauth://", line, len) == 0) {
     225                key = oath_key_from_uri(line);
     226        } else {
     227                openpam_log(PAM_LOG_ERROR,
     228                    "unrecognized key file format: %s", filename);
     229                key = NULL;
     230        }
     231        fclose(f);
     232        return (key);
     233}
Note: See TracChangeset for help on using the changeset viewer.