| #include <ndn-cpp-dev/security/identity-certificate.hpp> |
| #include <ndn-cpp-dev/encoding/block.hpp> |
| #include <ndn-cpp-dev/util/io.hpp> |
| #include <stdexcept> |
| #include "nlsr_sm.hpp" |
| #include "nlsr_km.hpp" |
| #include "nlsr.hpp" |
| |
| namespace nlsr |
| { |
| bool |
| KeyManager::initKeyManager(ConfParameter &cp) |
| { |
| initCertSeqFromFile(cp.getSeqFileDir()); |
| if( !loadAllCertificates(cp.getCertDir()) ) |
| { |
| return false; |
| } |
| nlsrRootKeyPrefix=cp.getRootKeyPrefix(); |
| string processIdentityName(cp.getRootKeyPrefix()); |
| processIdentityName += "/"; |
| processIdentityName += cp.getSiteName(); |
| processIdentityName += "/"; |
| processIdentityName += "R.Start"; |
| processIdentityName += "/"; |
| processIdentityName += cp.getRouterName(); |
| ndn::Name ri(processIdentityName); |
| std::cout<<"Router Identity: "<<ri.toUri()<<std::endl; |
| routerIdentity=ri; |
| processIdentityName += "/"; |
| processIdentityName += "nlsr"; |
| cout<<"Proces Identity Name: "<<processIdentityName<<endl; |
| ndn::Name identityName(processIdentityName); |
| processIdentity=identityName; |
| ndn::KeyChain::deleteIdentity(processIdentity); |
| processCertName = ndn::KeyChain::createIdentity(processIdentity); |
| cout<<"Certificate Name: "<<processCertName.toUri()<<endl; |
| processKeyName=processCertName.getPrefix(-2); |
| cout<<"Key Name: "<<processKeyName.toUri()<<endl; |
| ndn::shared_ptr<ndn::IdentityCertificate> cert = |
| getCertificate(processCertName); |
| signByIdentity(*(cert),routerIdentity); |
| certStore.addCertificate(cert, certSeqNo, true); |
| certStore.printCertStore(); |
| return true; |
| } |
| |
| bool |
| KeyManager::loadAllCertificates(std::string certDirPath) |
| { |
| std::string filePath=certDirPath; |
| if(filePath.empty()) |
| { |
| SequencingManager sm; |
| filePath=sm.getUserHomeDirectory(); |
| filePath+="/nlsrCertDir"; |
| } |
| return loadCertificate(filePath+"/root.cert", KEY_TYPE_ROOT) |
| && loadCertificate(filePath+"/site.cert", KEY_TYPE_SITE) |
| && loadCertificate(filePath+"/operator.cert", KEY_TYPE_OPERATOR) |
| && loadCertificate(filePath+"/router.cert", KEY_TYPE_ROUTER) ; |
| } |
| |
| bool |
| KeyManager::loadCertificate(std::string inputFile, nlsrKeyType keyType) |
| { |
| try |
| { |
| ndn::shared_ptr<ndn::IdentityCertificate> cert = |
| ndn::io::load<ndn::IdentityCertificate>(inputFile, ndn::io::BASE_64); |
| ndn::Name certName=cert->getName(); |
| switch(keyType) |
| { |
| case KEY_TYPE_ROOT: |
| certStore.addCertificate(cert, 10, true); |
| rootCertName=certName; |
| std::cout<<"Root Cert: "<<rootCertName<<std::endl; |
| break; |
| case KEY_TYPE_SITE: |
| certStore.addCertificate(cert, 10, true); |
| siteCertName=certName; |
| std::cout<<"Site Cert: "<<siteCertName<<std::endl; |
| break; |
| case KEY_TYPE_OPERATOR: |
| certStore.addCertificate(cert, 10, true); |
| opCertName=certName; |
| std::cout<<"Operator Cert: "<<opCertName<<std::endl; |
| break; |
| case KEY_TYPE_ROUTER: |
| certStore.addCertificate(cert, certSeqNo, true); |
| routerCertName=certName; |
| std::cout<<"Router Cert: "<<routerCertName<<std::endl; |
| break; |
| case KEY_TYPE_PROCESS: |
| certStore.addCertificate(cert, certSeqNo, true); |
| processCertName=certName; |
| std::cout<<"Process Cert: "<<processCertName<<std::endl; |
| break; |
| default: |
| break; |
| } |
| return true; |
| } |
| catch(std::exception& e) |
| { |
| return false; |
| } |
| return false; |
| } |
| |
| ndn::Name |
| KeyManager::getProcessCertName() |
| { |
| return processCertName; |
| } |
| |
| ndn::Name |
| KeyManager::getRouterCertName() |
| { |
| return routerCertName; |
| } |
| |
| ndn::Name |
| KeyManager::getOperatorCertName() |
| { |
| return opCertName; |
| } |
| |
| ndn::Name |
| KeyManager::getSiteCertName() |
| { |
| return siteCertName; |
| } |
| |
| ndn::Name |
| KeyManager::getRootCertName() |
| { |
| return rootCertName; |
| } |
| |
| uint32_t |
| KeyManager::getCertSeqNo() |
| { |
| return certSeqNo; |
| } |
| |
| void |
| KeyManager::setCerSeqNo(uint32_t csn) |
| { |
| certSeqNo=csn; |
| } |
| |
| void |
| KeyManager::initCertSeqFromFile(string certSeqFileDir) |
| { |
| certSeqFileNameWithPath=certSeqFileDir; |
| if( certSeqFileNameWithPath.empty() ) |
| { |
| SequencingManager sm; |
| certSeqFileNameWithPath=sm.getUserHomeDirectory(); |
| } |
| certSeqFileNameWithPath += "/nlsrCertSeqNo.txt"; |
| cout<<"Key Seq File Name: "<< certSeqFileNameWithPath<<endl; |
| std::ifstream inputFile(certSeqFileNameWithPath.c_str(),ios::binary); |
| if ( inputFile.good() ) |
| { |
| inputFile>>certSeqNo; |
| certSeqNo++; |
| } |
| else |
| { |
| certSeqNo=1; |
| } |
| writeCertSeqToFile(); |
| } |
| |
| void |
| KeyManager::writeCertSeqToFile() |
| { |
| std::ofstream outputFile(certSeqFileNameWithPath.c_str(),ios::binary); |
| outputFile<<certSeqNo; |
| outputFile.close(); |
| } |
| |
| bool |
| KeyManager::isNewCertificate(std::string certName, int checkSeqNum) |
| { |
| return certStore.isCertificateNewInStore(certName,checkSeqNum); |
| } |
| |
| std::pair<ndn::shared_ptr<ndn::IdentityCertificate>, bool> |
| KeyManager::getCertificateFromStore(const std::string certName, int checkSeqNum) |
| { |
| return certStore.getCertificateFromStore(certName, checkSeqNum); |
| } |
| |
| std::pair<ndn::shared_ptr<ndn::IdentityCertificate>, bool> |
| KeyManager::getCertificateFromStore(const std::string certName) |
| { |
| return certStore.getCertificateFromStore(certName); |
| } |
| |
| bool |
| KeyManager::addCertificate(ndn::shared_ptr<ndn::IdentityCertificate> pcert |
| , uint32_t csn, bool isv) |
| { |
| return certStore.addCertificate(pcert, csn, isv); |
| } |
| |
| std::pair<uint32_t, bool> |
| KeyManager::getCertificateSeqNum(std::string certName) |
| { |
| return certStore.getCertificateSeqNum(certName); |
| } |
| |
| nlsrKeyType |
| KeyManager::getKeyTypeFromName(const std::string keyName) |
| { |
| nlsrTokenizer nt(keyName,"/"); |
| std::string KEY("KEY"); |
| std::string opHandle("O.Start"); |
| std::string routerHandle("R.Start"); |
| std::string processHandle("nlsr"); |
| if ( nt.getTokenString(0,nt.getTokenPosition(KEY)-1) == nlsrRootKeyPrefix) |
| { |
| return KEY_TYPE_ROOT; |
| } |
| else if ( nt.doesTokenExist(opHandle) ) |
| { |
| return KEY_TYPE_OPERATOR; |
| } |
| else if ( nt.doesTokenExist(routerHandle) && |
| nt.doesTokenExist(processHandle)) |
| { |
| return KEY_TYPE_PROCESS; |
| } |
| else if ( nt.doesTokenExist(routerHandle) && |
| !nt.doesTokenExist(processHandle)) |
| { |
| return KEY_TYPE_ROUTER; |
| } |
| else |
| { |
| return KEY_TYPE_SITE; |
| } |
| } |
| |
| std::string |
| KeyManager::getRouterName(const std::string name) |
| { |
| std::string routerName; |
| std::string rkp(nlsrRootKeyPrefix); |
| nlsrTokenizer ntRkp(rkp,"/"); |
| nlsrTokenizer nt(name,"/"); |
| std::string KEY("KEY"); |
| std::string opHandle("O.Start"); |
| std::string routerHandle("R.Start"); |
| std::string processHandle("nlsr"); |
| std::string infoHandle("info"); |
| std::string lsaHandle("LSA"); |
| if ( nt.doesTokenExist(processHandle) && nt.doesTokenExist(routerHandle)) |
| { |
| routerName="/ndn" + |
| nt.getTokenString(ntRkp.getTokenNumber(), |
| nt.getTokenPosition(routerHandle)-1) + |
| nt.getTokenString(nt.getTokenPosition(routerHandle)+1, |
| nt.getTokenPosition(processHandle)-1); |
| } |
| else if(nt.doesTokenExist(routerHandle) && !nt.doesTokenExist(infoHandle) |
| && !nt.doesTokenExist(lsaHandle)) |
| { |
| routerName="/ndn" + |
| nt.getTokenString(ntRkp.getTokenNumber(), |
| nt.getTokenPosition(routerHandle)-1) + |
| nt.getTokenString(nt.getTokenPosition(routerHandle)+1, |
| nt.getTokenPosition(KEY)-1); |
| } |
| else |
| { |
| if (nt.doesTokenExist(infoHandle) ) |
| { |
| routerName=nt.getTokenString(0,nt.getTokenPosition(infoHandle)-1); |
| } |
| else |
| { |
| routerName=nt.getTokenString(nt.getTokenPosition(lsaHandle)+1, |
| nt.getTokenNumber()-4); |
| } |
| } |
| return routerName; |
| } |
| |
| std::string |
| KeyManager::getSiteName(const std::string name) |
| { |
| std::string siteName; |
| std::string routerName; |
| std::string rkp(nlsrRootKeyPrefix); |
| nlsrTokenizer ntRkp(rkp,"/"); |
| nlsrTokenizer nt(name,"/"); |
| std::string KEY("KEY"); |
| std::string opHandle("O.Start"); |
| std::string routerHandle("R.Start"); |
| if ( nt.doesTokenExist(routerHandle) ) |
| { |
| siteName="/ndn" + nt.getTokenString(ntRkp.getTokenNumber(), |
| nt.getTokenPosition(routerHandle) -1); |
| } |
| else if ( nt.doesTokenExist(opHandle) ) |
| { |
| siteName="/ndn" + nt.getTokenString(ntRkp.getTokenNumber(), |
| nt.getTokenPosition(opHandle) -1); |
| } |
| else |
| { |
| siteName="/ndn" + nt.getTokenString(ntRkp.getTokenNumber(), |
| nt.getTokenPosition(KEY) -1); |
| } |
| return siteName; |
| } |
| |
| std::string |
| KeyManager::getRootName(const std::string name) |
| { |
| std::string rName; |
| nlsrTokenizer nt(name,"/"); |
| std::string rkp(nlsrRootKeyPrefix); |
| nlsrTokenizer ntRkp(rkp,"/"); |
| rName=nt.getTokenString(0,ntRkp.getTokenNumber()-1); |
| return rName; |
| } |
| |
| |
| bool |
| KeyManager::verifyCertPacket(Nlsr& pnlsr, ndn::IdentityCertificate& packet) |
| { |
| std::cout<<"KeyManager::verifyCertPacket Called"<<std::endl; |
| ndn::SignatureSha256WithRsa signature(packet.getSignature()); |
| std::string signingCertName=signature.getKeyLocator().getName().toUri(); |
| std::string packetName=packet.getName().toUri(); |
| |
| std::cout<<"Packet Name: "<<packetName<<std::endl; |
| std::cout<<"Signee Name: "<<signingCertName<<std::endl; |
| |
| int paketCertType=getKeyTypeFromName(packetName); |
| int signingCertType=getKeyTypeFromName(signingCertName); |
| |
| if( signingCertType > paketCertType ) //lower level Cert can not sign |
| { //upper level Cert |
| return false; |
| } |
| |
| if((signingCertType == paketCertType) && (paketCertType != KEY_TYPE_ROOT)) |
| { |
| return false; |
| } |
| |
| std::pair<ndn::shared_ptr<ndn::IdentityCertificate>, bool> signee= |
| certStore.getCertificateFromStore(signingCertName); |
| |
| if( signee.second ) |
| { |
| switch(paketCertType) |
| { |
| case KEY_TYPE_ROOT: |
| return ((getRootName(packetName) == nlsrRootKeyPrefix) && |
| verifySignature(packet,signee.first->getPublicKeyInfo())); |
| break; |
| case KEY_TYPE_SITE: |
| return ((getRootName(packetName) == getRootName(signingCertName)) && |
| verifySignature(packet,signee.first->getPublicKeyInfo()) && |
| certStore.getCertificateIsVerified(signingCertName)); |
| break; |
| case KEY_TYPE_OPERATOR: |
| return ((getSiteName(packetName) == getSiteName(signingCertName)) && |
| verifySignature(packet,signee.first->getPublicKeyInfo()) && |
| certStore.getCertificateIsVerified(signingCertName)); |
| break; |
| case KEY_TYPE_ROUTER: |
| return ((getSiteName(packetName) == getSiteName(signingCertName)) && |
| verifySignature(packet,signee.first->getPublicKeyInfo()) && |
| certStore.getCertificateIsVerified(signingCertName)); |
| break; |
| case KEY_TYPE_PROCESS: |
| return ((getRouterName(packetName) == getRouterName(signingCertName)) && |
| verifySignature(packet,signee.first->getPublicKeyInfo()) && |
| certStore.getCertificateIsVerified(signingCertName)); |
| break; |
| } |
| } |
| else |
| { |
| std::cout<<"Certificate Not Found in store. Sending Interest"<<std::endl; |
| pnlsr.getIm().expressInterest(pnlsr, signingCertName, 3, |
| pnlsr.getConfParameter().getInterestResendTime()); |
| return false; |
| } |
| return false; |
| } |
| } |
| |
| |
| |