Return to acert_validator.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / plugins / acert

Annotation of embedaddon/strongswan/src/libstrongswan/plugins/acert/acert_validator.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  * Copyright (C) 2014 Martin Willi
        !             3:  * Copyright (C) 2014 revosec AG
        !             4:  *
        !             5:  * This program is free software; you can redistribute it and/or modify it
        !             6:  * under the terms of the GNU General Public License as published by the
        !             7:  * Free Software Foundation; either version 2 of the License, or (at your
        !             8:  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
        !             9:  *
        !            10:  * This program is distributed in the hope that it will be useful, but
        !            11:  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
        !            12:  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
        !            13:  * for more details.
        !            14:  */
        !            15: 
        !            16: #define _GNU_SOURCE
        !            17: #include <library.h>
        !            18: 
        !            19: #include "acert_validator.h"
        !            20: 
        !            21: #include <credentials/certificates/x509.h>
        !            22: #include <credentials/certificates/ac.h>
        !            23: 
        !            24: typedef struct private_acert_validator_t private_acert_validator_t;
        !            25: 
        !            26: /**
        !            27:  * Private data of an acert_validator_t object.
        !            28:  */
        !            29: struct private_acert_validator_t {
        !            30: 
        !            31:        /**
        !            32:         * Public acert_validator_t interface.
        !            33:         */
        !            34:        acert_validator_t public;
        !            35: };
        !            36: 
        !            37: /**
        !            38:  * Check if an AC can be trusted
        !            39:  */
        !            40: static bool verify(private_acert_validator_t *this, certificate_t *ac)
        !            41: {
        !            42:        certificate_t *issuer;
        !            43:        enumerator_t *enumerator;
        !            44:        bool verified = FALSE;
        !            45: 
        !            46:        if (!ac->get_validity(ac, NULL, NULL, NULL))
        !            47:        {
        !            48:                return FALSE;
        !            49:        }
        !            50:        DBG1(DBG_CFG, "verifying attribute certificate issued by \"%Y\"",
        !            51:                 ac->get_issuer(ac));
        !            52:        enumerator = lib->credmgr->create_trusted_enumerator(lib->credmgr, KEY_ANY,
        !            53:                                                                                                        ac->get_issuer(ac), TRUE);
        !            54:        while (enumerator->enumerate(enumerator, &issuer, NULL))
        !            55:        {
        !            56:                if (issuer->get_validity(issuer, NULL, NULL, NULL))
        !            57:                {
        !            58:                        if (lib->credmgr->issued_by(lib->credmgr, ac, issuer, NULL))
        !            59:                        {
        !            60:                                verified = TRUE;
        !            61:                                break;
        !            62:                        }
        !            63:                }
        !            64:        }
        !            65:        enumerator->destroy(enumerator);
        !            66: 
        !            67:        return verified;
        !            68: }
        !            69: 
        !            70: /**
        !            71:  * Apply AC group membership to auth config
        !            72:  */
        !            73: static void apply(private_acert_validator_t *this, ac_t *ac, auth_cfg_t *auth)
        !            74: {
        !            75:        enumerator_t *enumerator;
        !            76:        ac_group_type_t type;
        !            77:        chunk_t chunk;
        !            78: 
        !            79:        enumerator = ac->create_group_enumerator(ac);
        !            80:        while (enumerator->enumerate(enumerator, &type, &chunk))
        !            81:        {
        !            82:                if (type == AC_GROUP_TYPE_STRING)
        !            83:                {
        !            84:                        auth->add(auth, AUTH_RULE_GROUP,
        !            85:                                          identification_create_from_data(chunk));
        !            86:                }
        !            87:        }
        !            88:        enumerator->destroy(enumerator);
        !            89: }
        !            90: 
        !            91: METHOD(cert_validator_t, validate, bool,
        !            92:        private_acert_validator_t *this, certificate_t *subject,
        !            93:        certificate_t *issuer, bool online, u_int pathlen, bool anchor,
        !            94:        auth_cfg_t *auth)
        !            95: {
        !            96:        /* for X.509 end entity certs only */
        !            97:        if (pathlen == 0 && subject->get_type(subject) == CERT_X509)
        !            98:        {
        !            99:                x509_t *x509 = (x509_t*)subject;
        !           100:                enumerator_t *enumerator;
        !           101:                identification_t *id, *serial;
        !           102:                ac_t *ac;
        !           103: 
        !           104:                /* find attribute certificates by serial and issuer. A lookup by
        !           105:                 * the holder DN would work as well, but RFC 5755 recommends the use
        !           106:                 * of baseCertificateID. */
        !           107:                serial = identification_create_from_encoding(ID_KEY_ID,
        !           108:                                                                                                         x509->get_serial(x509));
        !           109:                enumerator = lib->credmgr->create_cert_enumerator(lib->credmgr,
        !           110:                                                                                CERT_X509_AC, KEY_ANY, serial, FALSE);
        !           111:                while (enumerator->enumerate(enumerator, &ac))
        !           112:                {
        !           113:                        id = ac->get_holderIssuer(ac);
        !           114:                        if (id && id->equals(id, subject->get_issuer(subject)))
        !           115:                        {
        !           116:                                if (verify(this, &ac->certificate))
        !           117:                                {
        !           118:                                        apply(this, ac, auth);
        !           119:                                }
        !           120:                        }
        !           121:                }
        !           122:                enumerator->destroy(enumerator);
        !           123:                serial->destroy(serial);
        !           124:        }
        !           125:        return TRUE;
        !           126: }
        !           127: 
        !           128: METHOD(acert_validator_t, destroy, void,
        !           129:        private_acert_validator_t *this)
        !           130: {
        !           131:        free(this);
        !           132: }
        !           133: 
        !           134: /**
        !           135:  * See header
        !           136:  */
        !           137: acert_validator_t *acert_validator_create()
        !           138: {
        !           139:        private_acert_validator_t *this;
        !           140: 
        !           141:        INIT(this,
        !           142:                .public = {
        !           143:                        .validator.validate = _validate,
        !           144:                        .destroy = _destroy,
        !           145:                },
        !           146:        );
        !           147: 
        !           148:        return &this->public;
        !           149: }