pana_security_assoc.cxx

/* BEGIN_COPYRIGHT                                                        */
/*                                                                        */
/* Open Diameter: Open-source software for the Diameter and               */
/*                Diameter related protocols                              */
/*                                                                        */
/* Copyright (C) 2002-2004 Open Diameter Project                          */
/*                                                                        */
/* This library is free software; you can redistribute it and/or modify   */
/* it under the terms of the GNU Lesser General Public License as         */
/* published by the Free Software Foundation; either version 2.1 of the   */
/* License, or (at your option) any later version.                        */
/*                                                                        */
/* This library is distributed in the hope that it will be useful,        */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of         */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU      */
/* Lesser General Public License for more details.                        */
/*                                                                        */
/* You should have received a copy of the GNU Lesser General Public       */
/* License along with this library; if not, write to the Free Software    */
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307    */
/* USA.                                                                   */
/*                                                                        */
/* In addition, when you copy and redistribute some or the entire part of */
/* the source code of this software with or without modification, you     */
/* MUST include this copyright notice in each copy.                       */
/*                                                                        */
/* If you make any changes that are appeared to be useful, please send    */
/* sources that include the changed part to                               */
/* diameter-developers@lists.sourceforge.net so that we can reflect your  */
/* changes to one unified version of this software.                       */
/*                                                                        */
/* END_COPYRIGHT                                                          */

#include "pana_sha1.h"
#include "pana_security_assoc.h"
#include "pana_exceptions.h"
#include "pana_memory_manager.h"

#define PANA_SA_DEBUG   0

diameter_octetstring_t &PANA_MacKey::MacKey(diameter_octetstring_t &msk,
                                            ACE_UINT32 ISN_pac,
                                            ACE_UINT32 ISN_paa)
{
    /*
       The PANA_MAC_Key is used to integrity protect PANA messages and 
       derived from the MSK in the following way: 
    
          PANA_MAC_KEY = The first N-bit of 
                         HMAC_SHA1(MSK, ISN_pac | ISN_paa | Session-ID) 

       where the value of N depends on the integrity protection  algorithm 
       in use, i.e., N=128 for HMAC-MD5 and N=160 for HMAC-SHA1. 
    
       The length of MSK MUST be N-bit or longer.  See section 4.1.6 for 
       the detailed usage of the PANA_MAC_Key. 
    */
    PANA_Sha1 sha1;
    sha1.Update((unsigned char*)msk.data(), msk.size());
    sha1.Update((unsigned char*)&ISN_pac, sizeof(ISN_pac));
    sha1.Update((unsigned char*)&ISN_paa, sizeof(ISN_paa));
    sha1.Final();

    char sbuf[PANA_MACGEN_HMACSIZE];
    ACE_OS::memset(sbuf, 0x0, sizeof(sbuf));
    sha1.GetHash((unsigned char*)sbuf);

    m_MacKey.assign((char*)(sbuf), sizeof(sbuf));

#if PANA_SA_DEBUG
    printf("EAP key: %d\n", msk.size());
    for (int i=0; i<msk.size(); i++) {
        printf("%02X ", ((char*)msk.data())[i]);
    }
    printf("\n");
#endif
    
    return (m_MacKey);
}

void PANA_SecurityAssociation::GenerateMacValue(AAAMessageBlock *panaPDU,
                                                diameter_octetstring_t &macValue)
{
    /*
       A PANA message can contain a MAC (Message Authentication Code) AVP 
       for cryptographically protecting the message. 
    
       When a MAC AVP is included in a PANA message, the value field of the 
       MAC AVP is calculated by using the PANA_MAC_Key in the following 
       way: 
    
           MAC AVP value = HMAC_SHA1(PANA_MAC_Key, PANA_PDU) 
    
       where PANA_PDU is the PANA message including the PANA header, with 
       the MAC AVP value field first initialized to 0.  
    */
    PANA_Sha1 sha1;
    sha1.Update((unsigned char*)m_MacKey.data(), m_MacKey.size());
    sha1.Update((unsigned char*)panaPDU->base(), panaPDU->length());
    sha1.Final();

    char sbuf[PANA_MACGEN_HMACSIZE];
    ACE_OS::memset(sbuf, 0x0, sizeof(sbuf));
    sha1.GetHash((unsigned char*)sbuf);
    macValue.assign((char*)sbuf, sizeof(sbuf));

#if PANA_SA_DEBUG
    printf("Master key: %d\n", m_MacKey.size());
    for (int i=0; i<m_MacKey.size(); i++) {
        printf("%02X ", ((char*)m_MacKey.data())[i]);
    }
    printf("\n");
    
    printf("PDU: %d\n", panaPDU->length());
    for (int i=0; i<panaPDU->length(); i++) {
        printf("%02X ", ((char*)panaPDU->base())[i]);
    }
    printf("\n");

    printf("MAC Value: %d\n", macValue.size());
    for (int i=0; i<macValue.size(); i++) {
        printf("%02X ", ((char*)macValue.data())[i]);
    }
    printf("\n");
#endif
}

bool PANA_SecurityAssociation::AddMacValue(PANA_Message &msg)
{
    AAAAvpContainerManager cm;
    AAAAvpContainerEntryManager em;

    AAAAvpContainer *c_macAvp = cm.acquire("Mac-Avp");
    AAAAvpContainerEntry *e = em.acquire(AAA_AVPDataType(AAA_AVP_MAC_TYPE));
    PANA_TVData_t &macAvp = e->dataRef(Type2Type<PANA_TVData_t>());
    c_macAvp->add(e);

    msg.avpList().add(c_macAvp);

    // init this to zero so we can compute true MAC
    char sbuf[PANA_MACGEN_HMACSIZE];
    ACE_OS::memset(sbuf, 0x0, sizeof(sbuf));
    macAvp.value.assign(sbuf, sizeof(sbuf));
    macAvp.type = PANA_MACGEN_HMACSHA1;

    PANA_MessageBuffer *rawBuf = PANA_MESSAGE_POOL()->malloc();

    PANA_HeaderParser hp;
    AAADictionaryOption opt(PARSE_STRICT, PANA_DICT_PROTOCOL_ID);
    hp.setRawData(reinterpret_cast<AAAMessageBlock*>(rawBuf));
    hp.setAppData(static_cast<PANA_MsgHeader*>(&msg));
    hp.setDictData(&opt);

    hp.parseAppToRaw();

    // Parse the payload
    PANA_PayloadParser pp;
    pp.setRawData(reinterpret_cast<AAAMessageBlock*>(rawBuf));
    pp.setAppData(&(msg.avpList()));
    pp.setDictData(msg.getDictHandle());

    pp.parseAppToRaw();

    // Re-do the header again to set the length
    msg.length(rawBuf->wr_ptr() - rawBuf->base());
    hp.parseAppToRaw();

    // generate mac value
    GenerateMacValue((AAAMessageBlock*)rawBuf, macAvp.value);
    PANA_MESSAGE_POOL()->free(rawBuf);
    msg.avpList().reset();
    return (true);
}

bool PANA_SecurityAssociation::ValidateMacValue(PANA_Message &msg)
{
    try {
        if (m_MSK.size() == 0) {
            throw (PANA_Exception(PANA_Exception::FAILED, 
                                  "Warning: No MSK installed"));
        }

        AAAAvpContainer* c_macAvp = msg.avpList().search("Mac-Avp");
        if (c_macAvp == 0) {
            throw (PANA_Exception(PANA_Exception::FAILED, 
                                  "No MAC value found in the message"));
        }
        PANA_TVData_t &macAvp = (*c_macAvp)[0]->dataRef(Type2Type<PANA_TVData_t>());

        // verify type
        if (macAvp.type != PANA_MACGEN_HMACSHA1) {
            throw (PANA_Exception(PANA_Exception::FAILED, 
                                  "Warning: MAC algorithm not supported"));
        }

        // temporarily save the MAC value and insert 0 mac
        diameter_octetstring_t mvalue;
        mvalue.assign(macAvp.value.data(), macAvp.value.size());

#if PANA_SA_DEBUG        
        printf("AVP Value: %d\n", mvalue.size());
        for (int i=0; i<mvalue.size(); i++) {
            printf("%02X ", ((char*)mvalue.data())[i]);
        }
        printf("\n");
#endif

        // reset to zero
        char sbuf[PANA_MACGEN_HMACSIZE];
        ACE_OS::memset(sbuf, 0x0, sizeof(sbuf));
        macAvp.value.assign(sbuf, sizeof(sbuf));
        macAvp.type = PANA_MACGEN_HMACSHA1;

        PANA_MessageBuffer *aBuffer = PANA_MESSAGE_POOL()->malloc();
        msg.avpList().reset();

        // parse the message 
        PANA_HeaderParser hp;
        AAADictionaryOption opt(PARSE_STRICT, PANA_DICT_PROTOCOL_ID);
        hp.setRawData(reinterpret_cast<AAAMessageBlock*>(aBuffer));
        hp.setAppData(static_cast<PANA_MsgHeader*>(&msg));
        hp.setDictData(&opt);

        hp.parseAppToRaw();

        // Parse the payload
        PANA_PayloadParser pp;
        pp.setRawData(reinterpret_cast<AAAMessageBlock*>(aBuffer));
        pp.setAppData(&(msg.avpList()));
        pp.setDictData(msg.getDictHandle());

        pp.parseAppToRaw();

        // Re-do the header again to set the length
        msg.length(aBuffer->wr_ptr() - aBuffer->base());
        hp.parseAppToRaw();

        GenerateMacValue((AAAMessageBlock*)aBuffer, macAvp.value);
        
        // do comparison
        if (! (macAvp.value == mvalue)) {
            ACE_DEBUG((LM_ERROR, "(%P|%t) MAC value is invalid\n"));
        }

        PANA_MESSAGE_POOL()->free(aBuffer);
        return (true);
    }
    catch (AAAErrorStatus st) {
        ACE_DEBUG((LM_ERROR, "(%P|%t) Parsing error is session transmitter\n"));
    }  
    catch (PANA_Exception &e) {
        ACE_DEBUG((LM_ERROR, "(%P|%t) %s\n", e.description().data()));
    }

    return (false);
}

---