Changeset 145

Show
Ignore:
Timestamp:
05/11/12 18:54:37 (8 years ago)
Author:
vsilva
Message:

Improve Signature Validations. Implement EMV CAP change. Improve Windows 64 bits Support. Some bug fixes...

Location:
middleware-offline/trunk
Files:
22 added
18 removed
62 modified

Legend:

Unmodified
Added
Removed
  • middleware-offline/trunk/_src/eidmw/applayer/APLCard.cpp

    r109 r145  
    3030#include "SigContainer.h" 
    3131#include "MiscUtil.h" 
     32#include "EMV-Cap-Helper.h" 
     33#include "SSLConnection.h" 
    3234 
    3335#include <time.h> 
     
    166168} 
    167169 
     170bool APL_Card::ChangeCapPin(const char * new_pin) 
     171{ 
     172 
     173        // TODO and notes: Detect usage of Pinpad readers (we'll need to do an unsecure PIN verify) 
     174        // and cases where the PINs will be asked interactively  
     175        char *encrypted_apdu = NULL; 
     176        const unsigned char IAS_PTEID_APPLET_AID[] = {0x60, 0x46, 0x32, 0xFF, 0x00, 0x01, 0x02}; 
     177        const unsigned char GEMSAFE_APPLET_AID[] = {0x60, 0x46, 0x32, 0xFF, 0x00, 0x00, 0x02}; 
     178 
     179        //Establish SSL Connection with otp server to get the CAP PIN Change APDU 
     180        SSLConnection conn; 
     181 
     182        char* cookie = conn.do_OTP_1stpost(); 
     183 
     184        if (cookie == NULL) 
     185                throw CMWEXCEPTION(EIDMW_OTP_PROTOCOL_ERROR); 
     186 
     187        //Get OTP Params from EMV-Applet 
     188        OTPParams otp_params, otp_params2; 
     189        EMVCapHelper cap_helper(this); 
     190        cap_helper.getOtpParams(&otp_params); 
     191        otp_params.pin = (char*)new_pin; 
     192 
     193        encrypted_apdu = conn.do_OTP_2ndpost(cookie, &otp_params); 
     194 
     195        if (encrypted_apdu != NULL) 
     196        { 
     197                char * response_code = cap_helper.changeCapPin(encrypted_apdu); 
     198                conn.do_OTP_3rdpost(cookie, response_code); 
     199                //Reset script counter only needed for Gemsafe Cards 
     200                if (this->getType() == APL_CARDTYPE_PTEID_IAS07) 
     201                { 
     202 
     203                        EMVCapHelper new_cap_helper(this); 
     204                        new_cap_helper.getOnlineTransactionParams(&otp_params2); 
     205                        otp_params2.pin = (char*)new_pin; 
     206                        char *cdol2 = conn.do_OTP_4thpost(cookie, &otp_params2); 
     207 
     208                        char *reset_response_code = new_cap_helper.resetScriptCounter(cdol2); 
     209                        conn.do_OTP_5thpost(cookie, reset_response_code); 
     210                } 
     211 
     212        } 
     213        else 
     214                throw CMWEXCEPTION(EIDMW_OTP_PROTOCOL_ERROR); 
     215 
     216        //Re-select the IAS applet before returning 
     217        bool IsGemsafe = this->getType() == APL_CARDTYPE_PTEID_IAS07; 
     218        CByteArray Cmd; 
     219 
     220        Cmd.Append(0x00); 
     221        Cmd.Append(0xA4);  
     222        Cmd.Append(0x04); 
     223        Cmd.Append(IsGemsafe ? 0x00 : 0x0C); 
     224        Cmd.Append(0x07); 
     225 
     226        if (IsGemsafe) 
     227                Cmd.Append(GEMSAFE_APPLET_AID, sizeof(GEMSAFE_APPLET_AID)); 
     228        else 
     229                Cmd.Append(IAS_PTEID_APPLET_AID, sizeof(IAS_PTEID_APPLET_AID)); 
     230 
     231        this->sendAPDU(Cmd); 
     232 
     233return true; 
     234 
     235 
     236} 
     237 
    168238void replace_lastdot_inplace(char* str_in) 
    169239{ 
     
    227297 
    228298        XadesSignature sig(this); 
     299        CByteArray *ts_data = NULL; 
    229300        const char **files_to_sign = new const char*[1]; 
    230301 
     
    234305                files_to_sign[0] = paths[i]; 
    235306                CByteArray &signature = sig.SignXades(files_to_sign, 1, timestamp); 
     307                if (timestamp) 
     308                        ts_data = &XadesSignature::mp_timestamp_data; 
    236309                 
    237310                const char *output_file = generateFinalPath(output_dir, paths[i]); 
    238                 StoreSignatureToDisk (signature, NULL, files_to_sign, 1, output_file); 
     311                StoreSignatureToDisk (signature, ts_data, files_to_sign, 1, output_file); 
    239312                delete []output_file; 
    240313 
     
    282355 
    283356        delete container; 
     357 
     358        //TODO: We need to sort out the multiple checks issue, error messages are 
     359        // getting overwritten by valid timestamp messages 
    284360         
    285361        result = XadesSignature::ValidateXades(sig_content, hashes, errors, error_len); 
    286362         
    287         if (timestamp.Size() > 0) 
    288                 result &= XadesSignature::ValidateTimestamp(sig_content, timestamp, errors, error_len); 
    289  
    290         else if (result) 
    291         //This indicates that we don't have any "success message" on *errors* parameter 
    292                 *error_len = 0;                  
     363        if (result) 
     364        { 
     365           if (timestamp.Size() > 0) 
     366                   result &= XadesSignature::ValidateTimestamp(sig_content, timestamp, errors, error_len); 
     367        } 
     368        unsigned long subject_len = XadesSignature::mp_subject_name.Size(); 
     369         
     370        if (errors[*error_len-1] != '\n') 
     371                strcat(errors, "\n"); 
     372 
     373        if (subject_len > 0) 
     374          strncat(errors, (const char*)XadesSignature::mp_subject_name.GetBytes(), 
     375            subject_len); 
    293376 
    294377        return result; 
  • middleware-offline/trunk/_src/eidmw/applayer/APLCard.h

    r82 r145  
    122122         
    123123        EIDMW_APL_API void SignXadesTIndividual(const char**, unsigned int, const char*); 
     124         
     125        EIDMW_APL_API bool ChangeCapPin(const char * new_pin); 
    124126 
    125127        /** 
     
    199201        EIDMW_APL_API void selectApplication(const CByteArray &applicationId) const; 
    200202 
    201     EIDMW_APL_API virtual CByteArray sendAPDU(const CByteArray& cmd,APL_Pin *pin=NULL,const char *csPinCode=""); 
     203        EIDMW_APL_API virtual CByteArray sendAPDU(const CByteArray& cmd,APL_Pin *pin=NULL,const char *csPinCode=""); 
    202204 
    203205        /** 
  • middleware-offline/trunk/_src/eidmw/applayer/APLCardPteid.cpp

    r133 r145  
    937937                                { 
    938938                                        if(NULL == (getCertificates()->addCert(m_fileCertRootSign,APL_CERTIF_TYPE_ROOT_SIGN,true,false,m_certificateCount,NULL,NULL))) 
    939                                                 throw CMWEXCEPTION(EIDMW_ERR_CHECK); 
    940                                         m_certificateCount++; 
    941                                 } 
    942                         } 
    943  
    944                         if(!m_fileCertRoot) 
    945                         { 
    946                                 m_fileCertRoot=new APL_CardFile_Certificate(this,PTEID_FILE_CERT_ROOT); 
    947                                 //If status ok, we add the certificate to the store 
    948                                 if(m_fileCertRoot->getStatus(true)==CARDFILESTATUS_OK) 
    949                                 { 
    950                                         if(NULL == (getCertificates()->addCert(m_fileCertRoot,APL_CERTIF_TYPE_ROOT,true,false,m_certificateCount,NULL,NULL))) 
    951939                                                throw CMWEXCEPTION(EIDMW_ERR_CHECK); 
    952940                                        m_certificateCount++; 
     
    13331321{ 
    13341322        CByteArray xml; 
    1335         string *ts, *sn, *sa; 
     1323        string *ts, *sn, *sa, *tk; 
    13361324        string rootATTRS; 
    13371325 
     
    13391327        sn = m_xmlUserRequestedInfo->getServerName(); 
    13401328        sa = m_xmlUserRequestedInfo->getServerAddress(); 
     1329        tk = m_xmlUserRequestedInfo->getTokenID(); 
    13411330 
    13421331        if(!bNoHeader) 
    13431332                xml+="<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"; 
    1344         if (ts && sn && sa){ 
     1333        if (ts || sn || sa || tk){ 
    13451334                xml+=XML_ROOT_S; 
    1346                 XML_ATTRIBUTE(xml,XML_ROOT_ELEMENT_ATTR_TIMESTAMP,ts->c_str()); 
    1347                 XML_ATTRIBUTE(xml,XML_ROOT_ELEMENT_ATTR_SERVERNAME,sn->c_str()); 
    1348                 XML_ATTRIBUTE(xml,XML_ROOT_ELEMENT_ATTR_SERVERADDRESS,sa->c_str()); 
     1335                if (ts){ 
     1336                        XML_ATTRIBUTE(xml,XML_ROOT_ELEMENT_ATTR_TIMESTAMP,ts->c_str()); 
     1337                } 
     1338                if (sn) { 
     1339                        XML_ATTRIBUTE(xml,XML_ROOT_ELEMENT_ATTR_SERVERNAME,sn->c_str()); 
     1340                } 
     1341                if (sa) { 
     1342                        XML_ATTRIBUTE(xml,XML_ROOT_ELEMENT_ATTR_SERVERADDRESS,sa->c_str()); 
     1343                } 
     1344                if (tk) { 
     1345                        XML_ATTRIBUTE(xml,XML_ROOT_ELEMENT_ATTR_TOKENID,tk->c_str()); 
     1346                } 
    13491347                xml+=XML_ROOT_E; 
    13501348        } else 
    13511349                xml+=XML_OPEN_TAG_NEWLINE(XML_ROOT_ELEMENT); 
     1350 
    13521351        xml+=m_card->getID().getXML(true,*m_xmlUserRequestedInfo); 
    13531352        xml+=m_card->getAddr().getXML(true, *m_xmlUserRequestedInfo); 
     
    13801379        _serverAddress = NULL; 
    13811380        _timeStamp = NULL; 
     1381        _tokenID = NULL; 
    13821382} 
    13831383 
     
    13851385{ 
    13861386        xmlSet = new set<enum XMLUserData>; 
    1387         _timeStamp = new string(timeStamp); 
    1388         _serverName = new string(serverName); 
    1389         _serverAddress = new string(serverAddress); 
     1387        _timeStamp = (timeStamp) ? new string(timeStamp) : NULL; 
     1388        _serverName = (serverName) ? new string(serverName) : NULL; 
     1389        _serverAddress = (serverAddress) ? new string(serverAddress) : NULL; 
     1390        _tokenID = NULL; 
     1391} 
     1392 
     1393APL_XmlUserRequestedInfo::APL_XmlUserRequestedInfo(const char *timeStamp, const char *serverName, const char *serverAddress, const char *tokenID) 
     1394{ 
     1395        xmlSet = new set<enum XMLUserData>; 
     1396 
     1397        _timeStamp = (timeStamp) ? new string(timeStamp) : NULL; 
     1398        _serverName = (serverName) ? new string(serverName) : NULL; 
     1399        _serverAddress = (serverAddress) ? new string(serverAddress) : NULL; 
     1400        _tokenID = (tokenID) ? new string(tokenID) : NULL; 
    13901401} 
    13911402 
     
    14001411        if (_serverName) 
    14011412                delete _serverName; 
     1413        if (_tokenID) 
     1414                delete _tokenID; 
    14021415} 
    14031416 
     
    14421455std::string* APL_XmlUserRequestedInfo::getServerAddress(){ 
    14431456        return _serverAddress; 
     1457} 
     1458 
     1459std::string* APL_XmlUserRequestedInfo::getTokenID(){ 
     1460        return _tokenID; 
    14441461} 
    14451462 
  • middleware-offline/trunk/_src/eidmw/applayer/APLCardPteid.h

    r82 r145  
    479479        EIDMW_APL_API APL_XmlUserRequestedInfo(); 
    480480        EIDMW_APL_API APL_XmlUserRequestedInfo(const char *timeStamp, const char *serverName, const char *serverAddress); 
     481        EIDMW_APL_API APL_XmlUserRequestedInfo(const char *timeStamp, const char *serverName, const char *serverAddress, const char *tokenID); 
    481482        EIDMW_APL_API ~APL_XmlUserRequestedInfo(); 
    482483        EIDMW_APL_API void add(XMLUserData xmlUData); 
     
    490491        std::string *getServerName(); 
    491492        std::string *getServerAddress(); 
     493        std::string *getTokenID(); 
    492494friend CByteArray APL_CCXML_Doc::getXML(bool bNoHeader); 
    493495friend CByteArray APL_DocEId::getXML(bool bNoHeader); 
     
    500502        std::string *_serverName; 
    501503        std::string *_serverAddress; 
     504        std::string *_tokenID; 
    502505}; 
    503506 
  • middleware-offline/trunk/_src/eidmw/applayer/APLCertif.cpp

    r133 r145  
    691691#ifdef WIN32 
    692692        errno_t werr; 
     693        path+= "\\"; //Quick Fix for a messy situation with the certificates subdir 
    693694#endif 
    694695        path+=SubDir; 
     
    726727 
    727728        err: 
    728         MWLOG(LEV_DEBUG, MOD_APL, L"APL_Certifs::foundCertificate: problem with file %s ", path.c_str()); 
     729        MWLOG(LEV_DEBUG, MOD_APL, L"APL_Certifs::foundCertificate: problem with file %ls ", utilStringWiden(string(path)).c_str()); 
    729730} 
    730731 
    731732APL_Certif *APL_Certifs::findIssuer(const APL_Certif *cert) 
    732733{ 
    733         return findIssuer(&cert->getData()); 
    734 } 
    735  
    736 APL_Certif *APL_Certifs::findIssuer(const CByteArray *data) 
    737 { 
    738         if(!data) 
    739                 return NULL; 
    740  
    741734        APL_Certif *issuer=NULL; 
    742735 
     
    746739        { 
    747740                issuer=itr->second; 
    748                 if(m_cryptoFwk->isIssuer(*data,issuer->getData())) 
     741                if(m_cryptoFwk->isIssuer(cert->getData(),issuer->getData())){ 
    749742                        return issuer; 
    750         } 
    751  
    752         //Check in the hard coded store 
    753         const unsigned char *const *pucIssuer; 
    754         int i; 
    755  
    756         //Comment code that is causing troubles on certificates 
    757         //we look in the hard coded root array 
    758         /*for(pucIssuer=_pteid_root_certs,i=0;*pucIssuer!=NULL;pucIssuer++,i++) 
    759         { 
    760                 CByteArray issuer_data(*pucIssuer,_pteid_root_certs_size[i]); 
    761  
    762                 if(m_cryptoFwk->isIssuer(*data,issuer_data)) 
    763                 { 
    764                         APL_Certif *issuer = addCert(issuer_data,APL_CERTIF_TYPE_ROOT,true); 
    765                         return issuer; 
    766                 } 
    767         }*/ 
    768  
    769         //we look in the hard coded issuer array 
    770         /*for(pucIssuer=_pteid_issuer_certs,i=0;*pucIssuer!=NULL;pucIssuer++,i++) 
    771         { 
    772                 CByteArray issuer_data(*pucIssuer,_pteid_issuer_certs_size[i]); 
    773  
    774                 if(m_cryptoFwk->isIssuer(*data,issuer_data)) 
    775                 { 
    776                         APL_Certif *issuer = addCert(issuer_data,APL_CERTIF_TYPE_CA,true); 
    777                         return issuer; 
    778                 } 
    779         }*/ 
    780  
     743                } 
     744        } 
    781745        return NULL; 
    782746} 
     
    13371301{ 
    13381302    //Make temporary fix to make certificates appear on certain IAS cards 
    1339     if(m_issuer==this) 
     1303    if(m_cryptoFwk->isSelfIssuer(getData())) 
    13401304                m_root=1; 
    13411305        else 
     
    13711335{ 
    13721336        //If this is the root, there is no issuer 
    1373         if(m_root) 
    1374                 return NULL; 
    1375  
     1337        if(m_root){ 
     1338                return this; 
     1339        } 
    13761340        return m_issuer; 
    13771341} 
  • middleware-offline/trunk/_src/eidmw/applayer/APLCrypto.cpp

    r133 r145  
    2323#include "cryptoFwkPteid.h" 
    2424#include "CardPteidDef.h" 
    25 //#include "EMV-Cap-Helper.h" 
    2625#include "Reader.h" 
    2726#include "MiscUtil.h" 
     
    692691{ 
    693692 
    694         if(!m_card->isVirtualCard()) 
    695                 return m_card->pinCmd(PIN_OP_VERIFY,m_pinP15,csPin,"",ulRemaining,bShowDlg); 
    696         else 
    697                 return false; 
     693        return m_card->pinCmd(PIN_OP_VERIFY,m_pinP15,csPin,"",ulRemaining,bShowDlg); 
    698694 
    699695} 
     
    702698{ 
    703699 
    704         if(!m_card->isVirtualCard()) 
    705                 return m_card->pinCmd(PIN_OP_CHANGE,m_pinP15,csPin1,csPin2,ulRemaining, bShowDlg); 
    706         else 
    707                 return false; 
     700        return m_card->pinCmd(PIN_OP_CHANGE,m_pinP15,csPin1,csPin2,ulRemaining, bShowDlg); 
    708701} 
    709702 
  • middleware-offline/trunk/_src/eidmw/applayer/EMV-Cap-Helper.cpp

    r109 r145  
    1 /* 
    2  * EMV-Cap-Helper.cpp 
     1/* **************************************************************************** 
    32 * 
    4  *  Created on: 2011/10/24 
    5  *      Author: Luis Medinas <luis.medinas@caixamagica.pt> 
     3 *  PTeID Middleware Project. 
     4 *  Copyright (C) 2011-2012 
     5 *  Luis Medinas <lmedinas@gmail.com> 
     6 *  Andre Guerreiro <andre.guerreiro@caixamagica.pt> 
    67 */ 
    78 
     
    2829#include "APLReader.h" 
    2930#include "Reader.h" 
    30 #include "sslconnection.h" 
     31#include "Log.h" 
    3132 
    3233#include "EMV-Cap-Helper.h" 
     
    3536{ 
    3637 
    37 EMVCapHelper::EMVCapHelper(APL_SmartCard *card) 
    38 { 
    39         std::cout << "EMVCapHelper" << std::endl; 
    40         m_card=card; 
    41  
    42         CByteArray oresp,oresp2; 
     38EMVCapHelper::EMVCapHelper(APL_Card *card) 
     39{ 
     40        const unsigned char a1[] = {0x80, 0xA8, 0x00, 0x00, 0x02, 0x83, 0x00}; 
     41        const unsigned char a2[] = {0x80, 0xCA, 0x9F, 0x17, 0x08}; 
     42        const unsigned char a3[] = {0x80, 0xCA, 0x9F, 0x17, 0x04}; 
     43        m_card = card; 
     44 
     45        CByteArray oresp; 
    4346        oresp.Append(0x00); 
    4447        oresp.Append(0xA4); 
     
    5356        oresp.Append(0x00); 
    5457        oresp.Append(0x01); 
    55         oresp2 = m_card->getCalReader()->SendAPDU(oresp); 
    56  
    57     std::cout << "TESTE\n" << std::endl; 
    58  
    59     CByteArray pan, arqc; 
    60     std::string panstr = GetPan().ToString(); 
    61     std::string arqcstr = GetArqc().ToString(); 
    62  
    63     getparameters("4786", panstr.c_str(), arqcstr.c_str(), 
    64                   CDOL1, ATC, PANSEQNUMBER, COUNTER, PINTRYCOUNTER); 
     58        oresp = m_card->getCalReader()->SendAPDU(oresp); 
     59 
     60        if (!checkSW12(oresp)) 
     61        { 
     62        MWLOG(LEV_ERROR, MOD_APL, L"Failed to Select EMV-CAP Applet! We're probably dealing with an unknown/unsupported card."); 
     63        } 
     64        m_card->getCalReader()->SendAPDU(CByteArray(a1, sizeof(a1))); 
     65        m_card->getCalReader()->SendAPDU(CByteArray(a2, sizeof(a2))); 
     66        m_card->getCalReader()->SendAPDU(CByteArray(a3, sizeof(a3))); 
     67 
     68        m_pan = (char *)malloc(30); 
     69        m_arqc = (char *)malloc(20); 
     70        m_atc = (char *)malloc(10); 
     71 
     72} 
     73 
     74bool EMVCapHelper::checkSW12(CByteArray &in) 
     75{ 
     76 
     77        unsigned long ulRespLen = in.Size(); 
     78 
     79        unsigned int ulSW12 = (unsigned int)(256 * in.GetByte(ulRespLen - 2) 
     80                        + in.GetByte(ulRespLen - 1)); 
     81 
     82        return ulSW12 == 0x9000; 
     83 
     84} 
     85 
     86 
     87bool EMVCapHelper::getOtpParams(OTPParams *otp_struct) 
     88{ 
     89 
     90        GetPan(); 
     91        GetArqc(0x00); 
     92 
     93        otp_struct->pan = m_pan; 
     94        otp_struct->atc = m_atc; 
     95        otp_struct->arqc = m_arqc; 
     96         
     97 
     98        otp_struct->cdol1 = CDOL1; 
     99        otp_struct->pan_seq_nr = PANSEQNUMBER; 
     100        otp_struct->counter = COUNTER; 
     101        otp_struct->pin_try_counter = PINTRYCOUNTER; 
     102 
     103        if (m_pan == NULL || m_arqc == NULL || m_pan == NULL) 
     104                return false; 
     105        else  
     106                return true; 
    65107 
    66108} 
     
    69111{ 
    70112 
    71 } 
    72 CByteArray EMVCapHelper::GetPan() 
    73 { 
    74         CByteArray osecpan, osecpansend, osecpanresp, osecpanrespget; 
    75         osecpan.Append(0x80); 
    76         osecpan.Append(0xA8); 
    77     osecpan.Append(0x00); 
    78         osecpan.Append(0x00); 
    79         osecpan.Append(0x02); 
    80         osecpan.Append(0x83); 
    81         osecpan.Append(0x00); 
    82  
    83         osecpansend = m_card->getCalReader()->SendAPDU(osecpan); 
     113        free(m_pan); 
     114        free(m_arqc);  
     115        free(m_atc);  
     116} 
     117 
     118void EMVCapHelper::GetPan() 
     119{ 
     120        CByteArray osecpanresp; 
    84121 
    85122        osecpanresp.Append(0x00); 
     
    89126        osecpanresp.Append(0x5F); 
    90127 
    91         osecpanrespget = m_card->getCalReader()->SendAPDU(osecpanresp); 
    92  
    93         CByteArray pannr = osecpanrespget.GetBytes(21,8); 
    94     std::cout << "PAN " << pannr.ToString() << std::endl; 
    95  
    96         return pannr; 
    97 } 
    98  
    99 CByteArray EMVCapHelper::GetArqc() 
    100 { 
    101         const unsigned char apdu[] = {0x80, 0xAE, 0x80, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
    102                                                                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 
    103                                                                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
    104                                                                   0x00, 0x34, 0x00, 0x00, 0x01, 0x00, 0x01}; 
     128        CByteArray osecpanrespget = m_card->getCalReader()->SendAPDU(osecpanresp); 
     129 
     130        std::string pan_tmp = osecpanrespget.GetBytes(21,8).ToString(false); 
     131 
     132        strcpy(m_pan, pan_tmp.c_str()); 
     133 
     134} 
     135 
     136char *EMVCapHelper::changeCapPin(char * change_apdu_str) 
     137{ 
     138 
     139        //Create APDU from hex-encoded string 
     140        CByteArray change_pin_apdu(std::string(change_apdu_str), true); 
     141        char *resp = (char *)malloc(5); 
     142 
     143        CByteArray bresp = m_card->getCalReader()->SendAPDU(change_pin_apdu); 
     144 
     145        unsigned long ulRespLen = bresp.Size(); 
     146 
     147        unsigned int ulSW12 = (unsigned int)(256 * bresp.GetByte(ulRespLen - 2) + bresp.GetByte(ulRespLen - 1)); 
     148        sprintf(resp, "%04x", ulSW12); 
     149 
     150        return resp; 
     151 
     152} 
     153 
     154char *EMVCapHelper::resetScriptCounter(char * cdol2) 
     155{ 
     156        //Example: 80 AE 40 00 11 00 00 00 00 00 00 00 00 00 00 5A 33 80 00 00 00 00 
     157        const unsigned char apdu_header[] = {0x80, 0xAE, 0x40, 0x00, 0x11}; 
     158        //Create APDU from hex-encoded string 
     159        CByteArray reset_counter_apdu; 
     160 
     161        if (cdol2 == NULL) 
     162        { 
     163                MWLOG(LEV_DEBUG, MOD_APL, L"resetScriptCounter called with cdol2 = NULL, ignoring the request..."); 
     164                return "9000"; 
     165 
     166        } 
     167        CByteArray body_apdu(std::string(cdol2), true); 
     168        char *resp = (char *)malloc(5); 
     169 
     170        reset_counter_apdu.Append(apdu_header, sizeof(apdu_header)); 
     171        reset_counter_apdu.Append(body_apdu); 
     172 
     173        CByteArray bresp = m_card->getCalReader()->SendAPDU(reset_counter_apdu); 
     174 
     175        unsigned long ulRespLen = bresp.Size(); 
     176 
     177        unsigned int ulSW12 = (unsigned int)(256 * bresp.GetByte(ulRespLen - 2) + bresp.GetByte(ulRespLen - 1)); 
     178        sprintf(resp, "%04x", ulSW12); 
     179 
     180        return resp; 
     181 
     182} 
     183 
     184void EMVCapHelper::getOnlineTransactionParams(OTPParams *otp_struct) 
     185{ 
     186        const unsigned char verify_apdu[] = { 
     187                0x00, 0x20, 0x00, 0x80, 0x08, 0x24, 0x12, 0x34, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF 
     188        }; 
     189 
     190        //Zero-out the whole struct, just in case 
     191        memset(otp_struct, 0, sizeof(OTPParams)); 
     192 
     193        CByteArray verify; 
     194        verify.Append(verify_apdu, sizeof(verify_apdu)); 
     195 
     196        //m_card->getCalReader()->SendAPDU(verify); 
     197        GetPan(); 
     198        GetArqc(0x80); 
     199 
     200        otp_struct->pan = m_pan; 
     201        otp_struct->atc = m_atc; 
     202        otp_struct->arqc = m_arqc; 
     203 
     204        otp_struct->cdol1 = CDOL1; 
     205        otp_struct->pan_seq_nr = PANSEQNUMBER; 
     206        otp_struct->counter = COUNTER; 
     207        otp_struct->pin_try_counter = PINTRYCOUNTER; 
     208} 
     209 
     210void EMVCapHelper::GetArqc(unsigned char p1) 
     211{ 
     212        const unsigned char apdu[] = {0x80, 0xAE, p1, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
     213                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 
     214                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
     215                0x00, 0x34, 0x00, 0x00, 0x01, 0x00, 0x01}; 
    105216 
    106217        CByteArray askarqc; 
     
    108219 
    109220        CByteArray aer= m_card->getCalReader()->SendAPDU(askarqc); 
    110         CByteArray arqnr = aer.GetBytes(15,8); 
    111     std::cout << "ARQC  " << arqnr.ToString() << std::endl; 
    112  
    113         return arqnr; 
    114  
    115 } 
    116  
    117 } 
     221        //We could try to properly parse the answer according to the scarce documentation 
     222        //but oh well, these offsets will never change in a million years... 
     223 
     224        std::string tmp = aer.GetBytes(14, 8).ToString(false); 
     225        strcpy(m_arqc, tmp.c_str()); 
     226 
     227        tmp = aer.GetBytes(9, 2).ToString(false); 
     228        strcpy(m_atc, tmp.c_str()); 
     229 
     230} 
     231 
     232} 
  • middleware-offline/trunk/_src/eidmw/applayer/EMV-Cap-Helper.h

    r15 r145  
    11/* 
    2  * EMV-Cap-Helper.h 
    3  * 
    4  *  Created on: 2011/10/24 
    5  *      Author: Luis Medinas <luis.medinas@caixamagica.pt> 
    6  */ 
    7  
    8 /* 
    9  *  pteid-mw-ng is free software; you can redistribute it and/or modify 
    10  *  it under the terms of the GNU General Public License as published by 
    11  *  the Free Software Foundation; either version 2 of the License, or 
    12  *  (at your option) any later version. 
    13  * 
    14  *  pteid-mw-ng is distributed in the hope that it will be useful, 
    15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
    16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    17  *  GNU Library General Public License for more details. 
    18  * 
    19  *  You should have received a copy of the GNU General Public License 
    20  *  along with this program; if not, write to: 
    21  *      The Free Software Foundation, Inc., 
    22  *      51 Franklin Street, Fifth Floor 
    23  *      Boston, MA  02110-1301, USA. 
     2 *  PTeID Middleware Project. 
     3 *  Copyright (C) 2011-2012 
     4 *  Luis Medinas <lmedinas@gmail.com> 
     5 *  Andre Guerreiro <andre.guerreiro@caixamagica.pt> 
    246 */ 
    257 
     
    3012{ 
    3113 
    32 #define ATC "0002" 
    3314#define PANSEQNUMBER "00" 
    3415#define CDOL1 "0000000000000000000000000000800000000000000000000000000000" 
     
    3617#define PINTRYCOUNTER "3" 
    3718 
     19struct OTPParams 
     20{ 
     21char *pan; 
     22char *pin; 
     23char *arqc; 
     24char *cdol1; 
     25char *atc; 
     26char *pan_seq_nr; 
     27char *counter; 
     28char *pin_try_counter; 
     29 
     30}; 
     31 
    3832class EMVCapHelper 
    3933{ 
    4034public: 
    41         EMVCapHelper(APL_SmartCard *card); 
     35        EMVCapHelper(APL_Card *card); 
    4236        /** 
    4337          * Destructor 
     
    4539        ~EMVCapHelper(); 
    4640 
    47         CByteArray GetPan(); 
    48         CByteArray GetArqc(); 
     41        void GetPan(); 
     42        void GetArqc(unsigned char p1); 
     43        bool getOtpParams(OTPParams *); 
     44        char *changeCapPin(char * change_apdu_str); 
     45        char *resetScriptCounter(char *cdol2); 
     46        void getOnlineTransactionParams(OTPParams *); 
    4947private: 
    50         APL_SmartCard *m_card; 
     48        bool checkSW12(CByteArray &in); 
     49        APL_Card *m_card; 
     50        char *m_pan; 
     51        char *m_arqc; 
     52        char *m_atc; 
    5153}; 
    5254 
  • middleware-offline/trunk/_src/eidmw/applayer/MiscUtil.cpp

    r35 r145  
    3636#ifndef WIN32 
    3737#include <unistd.h> 
     38#include <iconv.h> 
    3839#endif 
    3940#include <errno.h> 
     
    104105                *out = '\0'; 
    105106        } 
     107 
     108#ifdef WIN32 
     109//TODO: Needs testing... 
     110        char * utf8_to_latin1(char * in) 
     111        { 
     112                char* ansi = NULL; 
     113                int length = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)in, -1, NULL, 0); 
     114                if (length > 0) 
     115                { 
     116                        wchar_t* wide = new wchar_t[length]; 
     117                        MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)in, -1, wide, length); 
     118 
     119                        // convert it to ANSI, use setlocale() to set your locale, if not set 
     120                        size_t convertedChars = 0; 
     121                        ansi = new char[length]; 
     122                        wcstombs_s(&convertedChars, ansi, length, wide, _TRUNCATE); 
     123                } 
     124                return ansi; 
     125 
     126        } 
     127#else 
     128 
     129const char * OUTSET = "WINDOWS-1252"; 
     130const char * INSET = "UTF-8"; 
     131 
     132/* Iconv Wrapper for UNIX */ 
     133 
     134iconv_t 
     135iconv_init(void) 
     136{ 
     137    iconv_t conv_desc; 
     138    conv_desc = iconv_open (OUTSET, INSET); 
     139    if (conv_desc == (iconv_t)-1) { 
     140        /* Initialization failure. */ 
     141        if (errno == EINVAL) { 
     142            fprintf (stderr, 
     143                     "Conversion from '%s' to '%s' is not supported.\n", 
     144                     INSET, OUTSET); 
     145        } else { 
     146            fprintf (stderr, "Initialization failure: %s\n", 
     147                     strerror (errno)); 
     148        } 
     149    } 
     150    return conv_desc; 
     151} 
     152 
     153 
     154/* Convert UTF-8 into LATIN-1 using the iconv library. */ 
     155 
     156char * 
     157utf82latin1(iconv_t conv_desc, char * euc) 
     158{ 
     159    size_t iconv_value; 
     160    char * utf8; 
     161    size_t len; 
     162    size_t utf8len; 
     163    /* The variables with "start" in their name are solely for display 
     164       of what the function is doing. As iconv runs, it alters the 
     165       values of the variables, so these are for keeping track of the 
     166       start points and start lengths. */ 
     167    char * utf8start; 
     168    const char * euc_start; 
     169    int len_start; 
     170    int utf8len_start; 
     171 
     172    len = strlen (euc); 
     173    if (!len) { 
     174        fprintf (stderr, "Input string is empty.\n"); 
     175        return (0); 
     176    } 
     177    /* Assign enough space to put the Latin1. */ 
     178    utf8len = len; 
     179    utf8 = (char *)calloc (utf8len, 1); 
     180    /* Keep track of the variables. */ 
     181    len_start = len; 
     182    utf8len_start = utf8len; 
     183    utf8start = utf8; 
     184    euc_start = euc; 
     185    iconv_value = iconv (conv_desc, & euc, & len, & utf8, & utf8len); 
     186    /* Handle failures. */ 
     187    if (iconv_value == (size_t) -1) { 
     188        fprintf (stderr, "iconv failed: in string '%s', length %d, " 
     189                "out string '%s', length %d\n", 
     190                 euc, (int)len, utf8start, (int)utf8len); 
     191        switch (errno) { 
     192            /* See "man 3 iconv" for an explanation. */ 
     193        case EILSEQ: 
     194            fprintf (stderr, "Invalid multibyte sequence.\n"); 
     195            break; 
     196        case EINVAL: 
     197            fprintf (stderr, "Incomplete multibyte sequence.\n"); 
     198            break; 
     199        case E2BIG: 
     200            fprintf (stderr, "No more room.\n"); 
     201            break; 
     202        default: 
     203            fprintf (stderr, "Error: %s.\n", strerror (errno)); 
     204        } 
     205    } 
     206    return utf8start; 
     207} 
     208 
     209/* Close the connection with the library. */ 
     210 
     211void 
     212iconv_finalize (iconv_t conv_desc) 
     213{ 
     214    int v; 
     215    v = iconv_close (conv_desc); 
     216    if (v != 0) { 
     217        fprintf (stderr, "iconv_close failed: %s\n", strerror (errno)); 
     218    } 
     219} 
     220char * utf8_to_latin1(char * in) 
     221{ 
     222        iconv_t conv_desc; 
     223        conv_desc = iconv_init(); 
     224        char *out_string = utf82latin1(conv_desc, in); 
     225        iconv_finalize (conv_desc); 
     226 
     227        return out_string; 
     228 
     229} 
     230 
     231#endif 
    106232 
    107233/***************************************************************************************** 
     
    394520              // this is a regular file 
    395521              std::string file = pFile->d_name; 
    396               std::string ext="."; 
    397               ext+=Ext; 
     522              std::string ext = Ext; 
    398523              // check if the file has the requested extension 
    399524              if(strlen(Ext)==0 
  • middleware-offline/trunk/_src/eidmw/applayer/MiscUtil.h

    r35 r145  
    4141//Charset conversion 
    4242void latin1_to_utf8(unsigned char * in, unsigned char *out); 
     43char * utf8_to_latin1(char * in); 
    4344 
    4445//Common type between 2/3 different cpp files 
  • middleware-offline/trunk/_src/eidmw/applayer/SigContainer.h

    r109 r145  
    3333"" NL 
    3434"Download da Aplicação Oficial do Cartão de Cidadão:" NL 
    35 "http://svn.gov.pt/projects/ccidadao/browser/middleware-offline/tags/builds" NL 
     35"http://svn.gov.pt/projects/ccidadao" NL 
    3636"" NL 
    3737"Especificação Técnica da Assinatura Digital:" NL 
     
    5151"" NL 
    5252"Download Portuguese ID Card Management application:" NL 
    53 "http://svn.gov.pt/projects/ccidadao/browser/middleware-offline/tags/builds" NL 
     53"http://svn.gov.pt/projects/ccidadao" NL 
    5454"" NL 
    5555"Signature technical specification:" NL 
  • middleware-offline/trunk/_src/eidmw/applayer/XadesSignature.cpp

    r133 r145  
    11/** 
    2  * 
    3  * XAdES and XAdES-T signature generation for PT-Eid Middleware 
    4  * 
    5  * Author: André Guerreiro <andre.guerreiro@caixamagica.pt> 
    6  * 
    7  */ 
     2****************************************************************************** 
     3* 
     4**  PTeID Middleware Project. 
     5**  Copyright (C) 2011-2012 
     6**  Andre Guerreiro <andre.guerreiro@caixamagica.pt> 
     7** 
     8**  XAdES and XAdES-T signature generator and validator  
     9** 
     10** 
     11** 
     12*/ 
     13 
    814 
    915#include <iostream> 
     
    1824#include "MWException.h" 
    1925#include "eidErrors.h" 
     26#include "Util.h" 
     27#include "static_pteid_certs.h" 
    2028 
    2129#include "MiscUtil.h" 
    2230 
    23 // Timestamp.cc contains the implementation for local 
    24 // timestamp validation using OpenSSL 1.0. ATM its disabled because 
    25 // it complicates the deployment 
    26 //#include "Timestamp.h" 
    2731 
    2832#include "Log.h" 
     
    6468#include <openssl/sha.h> 
    6569#include <openssl/evp.h> 
     70#include <openssl/pem.h> 
    6671#include <openssl/bio.h> 
     72#include <openssl/err.h> 
    6773 
    6874//stat 
     
    9399 
    94100        CByteArray XadesSignature::mp_validate_data = CByteArray(); 
     101        CByteArray XadesSignature::mp_subject_name = CByteArray(); 
    95102 
    96103        CByteArray XadesSignature::HashFile(const char *file_path) 
     
    307314        } 
    308315 
    309         char *strip_backslashes(const char *str) 
     316        char *strip_newlines(const char *str) 
    310317        { 
    311318                char *cleaned = new char[strlen(str)]; 
     
    313320                for (unsigned int i=0; i < strlen(str); i++) 
    314321                { 
    315                         if (str[i] != '\n') //Skips all backslash sequences, it works for base64 strings 
     322                        if (str[i] != '\n') 
    316323                                cleaned[j++] = str[i];  
    317324                } 
     
    331338                CURLcode res; 
    332339                char error_buf[CURL_ERROR_SIZE]; 
     340 
     341                //Make sure the static array receiving the network reply  
     342                // is zero'd out before each request 
     343                mp_validate_data.Chop(mp_validate_data.Size()); 
    333344 
    334345                //Get Timestamping server URL from config 
     
    393404                        if (res != 0) 
    394405                        { 
    395                                 MWLOG(LEV_ERROR, MOD_APL, L"Timestamp Validation error in HTTP POST request. LibcURL returned %S\n",  
    396                                                 (char *)error_buf); 
     406                                MWLOG(LEV_ERROR, MOD_APL, L"Timestamp Validation error in HTTP POST request. LibcURL returned %ls\n",  
     407                                        utilStringWiden(string(error_buf)).c_str()); 
    397408                        } 
    398409 
     
    403414                        curl_formfree(formpost); 
    404415 
    405  
     416                        curl_global_cleanup(); 
    406417                } 
    407418 
     
    417428                char error_buf[CURL_ERROR_SIZE]; 
    418429 
     430                //Make sure the static array receiving the network reply  
     431                // is zero'd out before each request 
     432                mp_timestamp_data.Chop(mp_timestamp_data.Size()); 
     433 
    419434                //Get Timestamping server URL from config 
    420435                APL_Config tsa_url(CConfig::EIDMW_CONFIG_PARAM_XSIGN_TSAURL); 
     
    455470                        if (res != 0) 
    456471                        { 
    457                                 MWLOG(LEV_ERROR, MOD_APL, L"Timestamping error in HTTP POST request. LibcURL returned %S\n",  
    458                                                 (char *)error_buf); 
     472                                MWLOG(LEV_ERROR, MOD_APL, L"Timestamping error in HTTP POST request. LibcURL returned %ls\n",  
     473                                                utilStringWiden(string(error_buf)).c_str()); 
    459474                        } 
    460475 
     
    463478                        /* always cleanup */  
    464479                        curl_easy_cleanup(curl); 
     480                        curl_global_cleanup(); 
    465481 
    466482                } 
     
    533549 
    534550        bool res; 
     551        int j; 
    535552        tHashedFile *hashed_file=NULL; 
    536553 
    537         for (int j = 0; hashes[j] != NULL; j++) 
     554        for ( j = 0 ; hashes[j] != NULL; j++) 
    538555        {        
    539556                res = false;     
     
    556573                { 
    557574                        MWLOG (LEV_ERROR, MOD_APL, 
    558                                         L" checkExternalRefs(): SHA-1 Hash Value for file %s doesn't match.", 
    559                                         hashed_file->URI->c_str()); 
     575                                        L" checkExternalRefs(): SHA-1 Hash Value for file %ls doesn't match.", 
     576                                        utilStringWiden(*(hashed_file->URI)).c_str()); 
    560577                        return false; 
    561578                } 
     579        } 
     580         
     581        //If container has no signed files this test is automatically false 
     582        if (j == 0) 
     583        { 
     584                MWLOG (LEV_DEBUG, MOD_APL, L"checkExternalRefs(): Container has no signed files!"); 
     585                return false; 
    562586        } 
    563587 
     
    567591 
    568592/* 
    569  * A little HTML-scraping to get the validation result 
     593 * A little HTML-scraping to get the validation result and timestamp value 
    570594 */ 
    571595bool XadesSignature::grep_validation_result (char *time_and_date) 
     
    576600        const char * invalid_timestamp_pattern = "Selo Temporal n\xE3o corresponde ao ficheiro seleccionado"; 
    577601        const char * general_error_pattern = "Ocorreu um erro"; 
     602        const char * signed_by = getString(16); 
    578603        unsigned char *haystack = mp_validate_data.GetBytes(); 
    579604 
     
    586611        const char *ts_str = strstr((const char *)haystack, valid_timestamp_pattern); 
    587612 
     613        //Warning: magic offsets ahead... 
    588614        if (ts_str != NULL) 
    589615        { 
    590616                //Grab the TimeDate string 
    591                 strncpy(time_and_date, ts_str+36, 27); 
    592                 time_and_date[27] = 0; 
     617                strcat(time_and_date, signed_by); 
     618                strncpy(time_and_date+strlen(signed_by), ts_str+36, 27); 
     619                time_and_date[27+strlen(signed_by)] = '\n'; 
     620                time_and_date[28+strlen(signed_by)] = 0; 
    593621 
    594622                return true;  
     
    631659        if (signature.Size() == 0) 
    632660        { 
    633                 int err_len = _snprintf(errors, *error_length, getString(0)); 
     661                int err_len = _snprintf(errors, *error_length, "%s", getString(0)); 
    634662                *error_length = err_len; 
    635663                MWLOG(LEV_ERROR, MOD_APL, L"ValidateTimestamp() received empty Signature. This most likely means a corrupt zipfile"); 
     
    686714        char time_and_date[100]; 
    687715        unsigned int sig_len = 0; 
     716        memset(time_and_date, 0, sizeof(time_and_date)); 
    688717        XERCES_NS DOMDocument * theDOM = dynamic_cast<XERCES_NS DOMDocument *>(doc); 
    689718        DSIGSignature * sig = prov.newSignatureFromDOM(theDOM, sigNode); 
     
    692721 
    693722        const char* tmp = XMLString::transcode(sig->getSignatureValue()); 
    694         char *tmp2 = strip_backslashes(tmp); 
     723        char *tmp2 = strip_newlines(tmp); 
    695724        base64Decode(tmp2, strlen(tmp2), signature_bin, sig_len); 
    696725        SHA1(signature_bin, sig_len, signature_hash); 
     
    704733        if (mp_validate_data.Size() == 0) 
    705734        { 
    706                 *error_length = _snprintf(errors, *error_length, getString(8)); 
     735                *error_length = _snprintf(errors, *error_length, "%s", getString(8)); 
    707736                return false; 
    708737        } 
     
    713742                *error_length = _snprintf(errors, *error_length, "%s", time_and_date); 
    714743        else 
    715                 *error_length = _snprintf(errors, *error_length, getString(2)); 
     744                *error_length = _snprintf(errors, *error_length, "%s", getString(2)); 
    716745 
    717746        return result; 
     747 
     748} 
     749 
     750 
     751X509 *loadCertFromPEM(const char *pem_buffer) 
     752{ 
     753 
     754        char * final_pem = (char *)calloc(strlen(pem_buffer)+ 65, sizeof(char)); 
     755        strcat(final_pem, "-----BEGIN CERTIFICATE-----\n"); 
     756        strcat(final_pem, pem_buffer); 
     757        strcat(final_pem, "-----END CERTIFICATE-----\n"); 
     758 
     759        BIO *pem_bio = BIO_new_mem_buf((void *)final_pem, -1); 
     760        X509 *cert = NULL; 
     761 
     762        if (pem_bio != NULL) 
     763        { 
     764                cert = PEM_read_bio_X509(pem_bio, NULL, NULL, NULL); 
     765                if (cert == NULL) 
     766                        MWLOG(LEV_ERROR, MOD_APL, L"Error parsing certificate from PEM string!"); 
     767 
     768        } 
     769         
     770        BIO_free_all(pem_bio);   
     771        return cert; 
     772 
     773} 
     774 
     775X509 * loadCertFromB64Der(const char *base64_string) 
     776{ 
     777        X509 *cert = NULL; 
     778        unsigned int bufsize = strlen(base64_string); 
     779 
     780        unsigned char *der_buffer = (unsigned char *)malloc(bufsize); 
     781 
     782        base64Decode(base64_string, bufsize, der_buffer, bufsize); 
     783 
     784        if (der_buffer != NULL) 
     785        { 
     786                cert = d2i_X509(NULL, (const unsigned char**)(&der_buffer), bufsize); 
     787                 
     788                if (cert == NULL) 
     789                        MWLOG(LEV_ERROR, MOD_APL, L"Error parsing certificate from DER buffer!\n"); 
     790 
     791        } 
     792        return cert; 
     793 
     794} 
     795/* 
     796* This method validates the supplied PEM certificate. 
     797* To be used by ValidateXades() 
     798* 
     799*/ 
     800bool XadesSignature::ValidateCert(const char *pem_certificate) 
     801{ 
     802        if (pem_certificate == NULL || strlen(pem_certificate) == 0) 
     803                return false; 
     804 
     805        bool bStopRequest = false; 
     806        bool res = false; 
     807 
     808        OpenSSL_add_all_algorithms(); 
     809 
     810        X509_STORE *store = X509_STORE_new(); 
     811         
     812        X509 *pCert = NULL; 
     813        unsigned char * cert_data = NULL; 
     814        char *parsing_error = NULL; 
     815 
     816        /* 
     817        APL_Config certs_dir(CConfig::EIDMW_CONFIG_PARAM_GENERAL_CERTS_DIR); 
     818        const char * str_certs_dir = certs_dir.getString(); 
     819        CPathUtil::scanDir(str_certs_dir, "", "der", bStopRequest, store, &XadesSignature::foundCertificate); 
     820        */ 
     821 
     822        for (unsigned int i = 0; i != CERTS_N; 
     823                i++) 
     824        { 
     825                pCert = NULL; 
     826                cert_data = PTEID_CERTS[i].cert_data; 
     827            pCert = d2i_X509(&pCert, (const unsigned char **)&cert_data,  
     828                        PTEID_CERTS[i].cert_len); 
     829 
     830                if (pCert == NULL) 
     831                { 
     832                        parsing_error = ERR_error_string(ERR_get_error(), NULL); 
     833                MWLOG(LEV_ERROR, MOD_APL, L"XadesSignature::ValidateCert: Error parsing certificate #%d. Details: %s", 
     834                                i, parsing_error); 
     835                } 
     836                else 
     837                { 
     838                        if(X509_STORE_add_cert(store, pCert) == 0) 
     839                                printf("XadesSignature::ValidateCert: error adding certificate #%d\n",  i); 
     840                } 
     841         
     842        } 
     843         
     844        X509_STORE_CTX *ctx; 
     845        X509 *cert = NULL; 
     846 
     847        ctx = X509_STORE_CTX_new(); 
     848 
     849        if (ctx == NULL) 
     850        { 
     851                /* Bad error */ 
     852                return false; 
     853        } 
     854         
     855        cert = loadCertFromPEM(pem_certificate); 
     856 
     857        if (cert == NULL) 
     858        { 
     859                MWLOG(LEV_ERROR, MOD_APL, L"ValidateCert(): Broken or corrupt certificate"); 
     860                return false; 
     861        } 
     862 
     863        //Load cert chain into store 
     864 
     865        X509_STORE_CTX_init(ctx, store, cert, NULL); 
     866 
     867        X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_CB_ISSUER_CHECK); 
     868         
     869        int validate_res = X509_verify_cert(ctx); 
     870 
     871        if (validate_res == 1) 
     872        { 
     873                MWLOG(LEV_DEBUG, MOD_APL, L"ValidateCert(): Valid certificate"); 
     874                res = true; 
     875        } 
     876        else 
     877        { 
     878                res = false; 
     879                char subject_buf[1024]; 
     880                std::string ssl_error = std::string(X509_verify_cert_error_string(ctx->error)); 
     881                MWLOG(LEV_DEBUG, MOD_APL, L"ValidateCert(): Invalid certificate! OpenSSL Error: %ls",  
     882                        utilStringWiden(ssl_error).c_str()); 
     883 
     884                X509* error_cert = X509_STORE_CTX_get_current_cert(ctx); 
     885                X509_NAME_oneline(X509_get_subject_name(ctx->current_cert), subject_buf, sizeof(subject_buf)); 
     886                std::string subject_str = std::string(subject_buf); 
     887                MWLOG(LEV_DEBUG, MOD_APL, L"Certificate that caused the error: %ls", 
     888                        utilStringWiden(subject_str).c_str()); 
     889 
     890        } 
     891 
     892        X509_STORE_CTX_free(ctx); 
     893        return res; 
     894 
     895} 
     896 
     897void XadesSignature::foundCertificate (const char *SubDir, const char *File, void *param) 
     898{ 
     899        X509_STORE *certificate_store =  (X509_STORE *)param; 
     900        APL_Config certs_dir(CConfig::EIDMW_CONFIG_PARAM_GENERAL_CERTS_DIR); 
     901        string path = string(certs_dir.getString()); 
     902        FILE *m_stream; 
     903        X509 *pCert = NULL; 
     904        long int bufsize; 
     905        unsigned char *buf; 
     906 
     907#ifdef WIN32 
     908        errno_t werr; 
     909        path += "\\"; 
     910#endif 
     911        path+=SubDir; 
     912#ifdef WIN32 
     913        path += "\\"; 
     914#else 
     915        path+= "/"; 
     916#endif 
     917        path+=File; 
     918         
     919#ifdef WIN32 
     920        if ((werr = fopen_s(&m_stream, path.c_str(), "rb")) != 0) 
     921                goto err; 
     922#else 
     923        if ((m_stream = fopen(path.c_str(), "rb")) == NULL) 
     924                goto err; 
     925#endif 
     926 
     927        if (fseek( m_stream, 0L, SEEK_END)) 
     928                goto err; 
     929 
     930        bufsize = ftell(m_stream); 
     931        buf = (unsigned char *) malloc(bufsize*sizeof(unsigned char)); 
     932 
     933        if (fseek(m_stream, 0L, SEEK_SET)){ 
     934                free(buf); 
     935                goto err; 
     936        } 
     937 
     938        if (fread(buf, sizeof( unsigned char ), bufsize, m_stream) != bufsize) 
     939                goto err; 
     940 
     941        pCert = d2i_X509(&pCert, (const unsigned char **)&buf, bufsize); 
     942        if (pCert == NULL) 
     943           goto err; 
     944         
     945        if(X509_STORE_add_cert(certificate_store, pCert) == 0) 
     946           goto err; 
     947         
     948        MWLOG(LEV_DEBUG, MOD_APL, L"XadesSignature::foundCertificate: successfully added cert %ls",  
     949                        utilStringWiden(path).c_str()); 
     950        return; 
     951 
     952 
     953        err: 
     954                MWLOG(LEV_DEBUG, MOD_APL, L"XadesSignature::foundCertificate: problem with file %ls ",  
     955                        utilStringWiden(path).c_str()); 
     956 
     957} 
     958 
     959char * XadesSignature::parseSubjectFromCert(const char *cert_buffer) 
     960{ 
     961 
     962        //Subject name 
     963        X509 *cert; 
     964        const int BUFSIZE = 500; 
     965 
     966        if ((cert = loadCertFromPEM(cert_buffer)) == NULL) 
     967                return NULL; 
     968 
     969        char *subject = (char *)malloc(BUFSIZE*sizeof(unsigned char)); 
     970 
     971        X509_NAME_get_text_by_NID(X509_get_subject_name(cert), NID_commonName, subject, BUFSIZE); 
     972 
     973        return subject; 
    718974 
    719975} 
     
    7731029        if (errorsOccured) { 
    7741030                //Write to output report  
    775                 int err_len = _snprintf(errors, *error_length, getString(4)); 
     1031                int err_len = _snprintf(errors, *error_length, "%s", getString(4)); 
    7761032                *error_length = err_len; 
    7771033                MWLOG(LEV_ERROR, MOD_APL, L"Errors parsing XML Signature, bailing out"); 
     
    8161072        sig->registerIdAttributeName(MAKE_UNICODE_STRING("ID")); 
    8171073 
    818  
    8191074        bool result = false; 
    8201075        bool extern_result = false;  
    8211076        try { 
    822          
     1077 
    8231078                sig->load(); 
     1079                                 
     1080                // Validate signing certificate first 
     1081                DSIGKeyInfo *keyinfo = sig->getKeyInfoList()->item(0); 
     1082                // If keyinfo is NULL this most certainly means a broken signature 
     1083                // just skip certificate checking 
     1084                if (keyinfo != NULL) 
     1085                { 
     1086 
     1087                        //This should always be the case for signatures created by pteid-mw 
     1088                        if (keyinfo->getKeyInfoType() == DSIGKeyInfo::KEYINFO_X509) 
     1089                        { 
     1090                                DSIGKeyInfoX509 *cert_element = dynamic_cast<DSIGKeyInfoX509 *> (keyinfo); 
     1091                                const XMLCh *pem_cert = cert_element->getCertificateItem(0); 
     1092                                char * tmp_cert = XMLString::transcode(pem_cert); 
     1093                                 
     1094                                //Clear the static array 
     1095                                mp_subject_name.Chop(mp_subject_name.Size()); 
     1096                                //Parse the signer's name from the certificate 
     1097                                char * subject_name = utf8_to_latin1( 
     1098                                           parseSubjectFromCert(tmp_cert)); 
     1099 
     1100                                if (subject_name != NULL) 
     1101                                { 
     1102                                        mp_subject_name.Append(CONST_STR getString(14), strlen(getString(14))); 
     1103                                        mp_subject_name.Append(CONST_STR " ", 1); 
     1104                                        mp_subject_name.Append(CONST_STR subject_name, strlen(subject_name)); 
     1105                                } 
     1106                                bool cert_result = ValidateCert(tmp_cert); 
     1107 
     1108                                if (!cert_result) 
     1109                                { 
     1110                                        int err_len = _snprintf(errors, *error_length, "%s",  getString(12)); 
     1111                                        *error_length = err_len; 
     1112                                        return false; 
     1113                                } 
     1114                                 
     1115                                         
     1116 
     1117                                 
     1118                                XMLString::release(&tmp_cert); 
     1119                        } 
     1120                } 
     1121                 
    8241122 
    8251123                DSIGReferenceList *refs = sig->getReferenceList(); 
     1124 
    8261125                if (refs != NULL) 
    8271126                        extern_result = checkExternalRefs(refs, hashes); 
    8281127                if (!extern_result) 
    8291128                { 
    830                         int err_len = _snprintf(errors, *error_length, getString(6)); 
     1129                        int err_len = _snprintf(errors, *error_length, "%s",  getString(6)); 
    8311130                        *error_length = err_len; 
    8321131                        return false; 
     
    8371136        } 
    8381137        catch (XSECException &e) { 
    839                 char * msg = XMLString::transcode(e.getMsg()); 
    840                 cerr << "An error occured during signature verification\n  (1) XMLSec Error Message: " 
    841                         << msg << endl; 
    842                 XSEC_RELEASE_XMLCH(msg); 
     1138                MWLOG(LEV_ERROR, MOD_APL, L"ValidateXades(): XSECException thrown. Detail: %ls", 
     1139                        e.getMsg()); 
    8431140                result = false; 
    844                  
    8451141        } 
    8461142        catch (XSECCryptoException &e) { 
    847                 cerr << "An error occured during signature verification\n  (2) XMLSec Error Message: " 
    848                         << e.getMsg() << endl; 
     1143                MWLOG(LEV_ERROR, MOD_APL, L"ValidateXades(): XSECCryptoException thrown. Detail: %ls", 
     1144                        e.getMsg()); 
    8491145                return false; 
    8501146        } 
     
    8521148        if (result == false) 
    8531149        { 
    854                 int err_len = _snprintf(errors, *error_length, "Validation error: RSA Signature of referenced content is invalid"); 
     1150                int err_len = _snprintf(errors, *error_length, "%s", getString(10)); 
    8551151                *error_length = err_len; 
    8561152        } 
  • middleware-offline/trunk/_src/eidmw/applayer/XadesSignature.h

    r133 r145  
    1818 
    1919#define XERCES_NS XERCES_CPP_NAMESPACE_QUALIFIER 
     20 
     21#define CONST_STR (const unsigned char *) 
    2022 
    2123#ifndef WIN32 
     
    4951                "Timestamp Validation: Internal Error, couldn't validate timestamp",  
    5052                "Validação de Selo Temporal: Erro Interno, não foi possível validar o selo temporal",  
     53                "Validation error: RSA Signature of referenced content is invalid", 
     54                "Erro de validação da assinatura: A assinatura criptográfica do conteúdo está inválida", 
     55                "Validation Error: The certificate used to sign this data is not trusted", 
     56                "Erro de validação da assinatura: O certificado contido na assinatura não provém de uma fonte confiável", 
     57                "Signed by:", 
     58                "Assinado por:", 
     59                "Timestamp: ", 
     60                "Selo temporal: " 
    5161        }; 
    5262 
     
    6777                CByteArray &SignXades(CByteArray ba, const char *URL); 
    6878                CByteArray &SignXades(const char ** paths, unsigned int n_paths, bool do_timestamp); 
    69  
     79                 
     80                static bool ValidateCert(const char *pem_certificate); 
     81                static void foundCertificate (const char *SubDir, const char *File, void *param); 
    7082                static bool checkExternalRefs(DSIGReferenceList *refs, tHashedFile **hashes); 
    7183                static bool ValidateXades(CByteArray signature, tHashedFile **hashes, char *errors, unsigned long *error_length); 
     
    7688                static CByteArray mp_timestamp_data; 
    7789                static CByteArray mp_validate_data; 
     90                static CByteArray mp_subject_name; 
    7891                static void do_post_validate_timestamp(char *input, long input_len, char *sha1_string); 
    7992 
     
    8396                 
    8497                CByteArray HashFile(const char *file_path); 
     98                static char * parseSubjectFromCert(const char *cert); 
    8599                DOMNode * addSignatureProperties(DSIGSignature *sig); 
    86100                CByteArray *WriteToByteArray(XERCES_NS DOMDocument *doc);  
  • middleware-offline/trunk/_src/eidmw/applayer/applayer.pro

    r82 r145  
    6666        APLCrypto.h \ 
    6767        APLDoc.h \ 
    68         EMV-Cap-Helper.h \ 
    6968        APLReader.h \ 
    7069        APLConfig.h \ 
     
    8483        SigContainer.h \ 
    8584        XadesSignature.h \ 
    86         SODParser.h 
     85        SODParser.h \  
     86        EMV-Cap-Helper.h \ 
     87        SSLConnection.h          
    8788 
    88  
    89 ### EMV-CAP support 
    90 ###        EMV-Cap-Helper.h \ 
    91 ###     sslcommon.h \ 
    92 ###     sslclient.h \ 
    93 ###     sslconnection.h \ 
    9489 
    9590SOURCES += \ 
     
    10297        CertStatusCache.cpp  \ 
    10398        cryptoFramework.cpp  \ 
    104     APLCard.cpp          \  
    105     XMLParser.cpp       \ 
    106     MiscUtil.cpp \ 
    107     PhotoPteid.cpp \ 
    108     APLPublicKey.cpp \ 
    109     SigContainer.cpp \ 
    110     XadesSignature.cpp \ 
    111     SODParser.cpp 
    112      
    113      
    114 ### EMV-CAP support 
    115 ###    EMV-Cap-Helper.cpp \ 
    116 ###    sslcommon.cpp            \ 
    117 ###    sslclient.cpp            \ 
    118 ###    sslconnection.cpp   \ 
     99        APLCard.cpp          \  
     100        XMLParser.cpp       \ 
     101        MiscUtil.cpp \ 
     102        PhotoPteid.cpp \ 
     103        APLPublicKey.cpp \ 
     104        SigContainer.cpp \ 
     105        XadesSignature.cpp \ 
     106        SODParser.cpp \ 
     107        SSLConnection.cpp \ 
     108        static_pteid_certs.cpp \ 
     109        EMV-Cap-Helper.cpp 
     110 
     111# Disable annoying and mostly useless gcc warning 
     112QMAKE_CXXFLAGS += -Wno-write-strings 
    119113 
    120114 
  • middleware-offline/trunk/_src/eidmw/applayer/cryptoFramework.cpp

    r41 r145  
    372372        //Convert cert into pX509 
    373373        pucCert=cert.GetBytes(); 
    374          
     374 
    375375        if ( ! d2i_X509_Wrapper(&pX509, pucCert,cert.Size() ) ) 
    376376          throw CMWEXCEPTION(EIDMW_ERR_CHECK); 
     
    498498bool APL_CryptoFwk::VerifyCertSignature(X509 *pX509_Cert,X509 *pX509_Issuer) 
    499499{ 
     500        bool bOk = false; 
     501 
    500502        if(pX509_Cert==NULL || pX509_Issuer==NULL) 
    501503                throw CMWEXCEPTION(EIDMW_ERR_CHECK); 
    502  
    503         bool bOk = false; 
    504504 
    505505        //Convert pX509_Cert->cert_info into unsigned char * and then into CByteArray 
     
    508508        if(lLen > 0) 
    509509        { 
     510                OpenSSL_add_all_digests(); 
    510511                //Convert the signature into CByteArray 
    511512                CByteArray signature(pX509_Cert->signature->data,pX509_Cert->signature->length); 
    512  
    513513                pucInfo = pucInfoNext = (unsigned char *)malloc(lLen);  //Allocate the buffer 
    514514                i2d_X509_CINF(pX509_Cert->cert_info,&pucInfoNext);              //Fill the buffer 
     
    516516                free(pucInfo);                                                                                  //Free buffer 
    517517 
     518                const EVP_MD *algorithm; 
     519                int i=OBJ_obj2nid(pX509_Cert->sig_alg->algorithm); 
     520                const char *algoName=OBJ_nid2sn(i); 
     521                algorithm=EVP_get_digestbyname(algoName); 
     522                if(algorithm==NULL) 
     523                        algorithm=EVP_sha1(); 
     524 
    518525                //Verify if the signature of the certinfo is correct (regarding the issuer certificate) 
    519                 bOk=VerifySignature(certinfo,signature,pX509_Issuer,EVP_sha1()); 
     526                bOk=VerifySignature(certinfo,signature,pX509_Issuer,algorithm); 
    520527        } 
    521528 
  • middleware-offline/trunk/_src/eidmw/applayer/pteid35applayer.vcproj

    r109 r145  
    418418                        </File> 
    419419                        <File 
     420                                RelativePath=".\EMV-Cap-Helper.cpp" 
     421                                > 
     422                        </File> 
     423                        <File 
    420424                                RelativePath=".\MiscUtil.cpp" 
    421425                                > 
     
    435439                        <File 
    436440                                RelativePath=".\SODParser.h" 
     441                                > 
     442                        </File> 
     443                        <File 
     444                                RelativePath=".\SSLConnection.cpp" 
     445                                > 
     446                        </File> 
     447                        <File 
     448                                RelativePath=".\static_pteid_certs.cpp" 
    437449                                > 
    438450                        </File> 
     
    540552                        </File> 
    541553                        <File 
     554                                RelativePath=".\EMV-Cap-Helper.h" 
     555                                > 
     556                        </File> 
     557                        <File 
    542558                                RelativePath=".\MiscUtil.h" 
    543559                                > 
     
    549565                        <File 
    550566                                RelativePath=".\SigContainer.h" 
     567                                > 
     568                        </File> 
     569                        <File 
     570                                RelativePath=".\SSLConnection.h" 
     571                                > 
     572                        </File> 
     573                        <File 
     574                                RelativePath=".\static_pteid_certs.h" 
    551575                                > 
    552576                        </File> 
  • middleware-offline/trunk/_src/eidmw/cardlayer/Card.cpp

    r133 r145  
    6363{ 
    6464        m_poContext->m_bSSO = value; 
     65        if (!value) 
     66        { 
     67                //Zero-out currently stored PINs 
     68                for (size_t i = 0; i < m_verifiedPINs.size(); i++) 
     69                { 
     70                        std::string &pin = m_verifiedPINs[i]; 
     71                        std::fill(pin.begin(), pin.end(), 0); 
     72                } 
     73        } 
    6574} 
    6675 
  • middleware-offline/trunk/_src/eidmw/cardlayer/Card.h

    r133 r145  
    155155        std::string m_csSerialNr; 
    156156 
     157    std::map <unsigned int, std::string> m_verifiedPINs; 
    157158    unsigned char m_ucCLA; 
    158159 
  • middleware-offline/trunk/_src/eidmw/cardlayer/PCSC.cpp

    r133 r145  
    465465        if (SCARD_S_SUCCESS != lRet) 
    466466        { 
     467#ifndef WIN32            
     468                //Special-casing the PIN Blocked response for GemPC Pinpad under pcscd 
     469                if (lRet == SCARD_E_NOT_TRANSACTED) 
     470                { 
     471                        pucRecv[0] = 0x64; 
     472                        pucRecv[1] = 0x02; 
     473                        dwRecvLen = 2; 
     474                } 
     475                else 
     476                { 
     477#endif                   
    467478                MWLOG(LEV_DEBUG, MOD_CAL, L"        SCardControl() err: 0x%0x", lRet); 
    468479                delete pucRecv; 
    469480                throw CMWEXCEPTION(PcscToErr(lRet)); 
     481#ifndef WIN32 
     482                } 
     483#endif           
    470484        } 
    471485 
  • middleware-offline/trunk/_src/eidmw/cardlayer/PkiCard.cpp

    r133 r145  
    271271        bRet = true; 
    272272        ulRemaining = 3; 
    273     } else if (ulSW12 == 0x6983) 
     273    } else if (ulSW12 == 0x6984) 
    274274        ulRemaining = 0; 
     275    //Special case for the GemPC Pinpad Reader 
     276    else if (operation == PIN_OP_VERIFY && ulSW12 == 0x6402) 
     277            ulRemaining = 0; 
    275278    else if (ulSW12 / 16 == 0x63C) 
    276279        ulRemaining = ulSW12 % 16; 
     
    424427    }else if (ulSW12 == 0x6983) 
    425428        ulRemaining = 0; 
     429    //Special case for the GemPC Pinpad Reader 
     430    else if (operation == PIN_OP_VERIFY && ulSW12 == 0x6402) 
     431            ulRemaining = 0; 
    426432    else if (ulSW12 / 16 == 0x63C) 
    427433        ulRemaining = ulSW12 % 16; 
     
    469475{ 
    470476 
    471         MWLOG(LEV_INFO, MOD_CAL, L"     No SSO: ask PIN and sign (key: ID=0x%0x, algo=0x%0x, " 
     477        MWLOG(LEV_INFO, MOD_CAL, L"PKiCard::Sign(): ask PIN and sign (key: ID=0x%0x, algo=0x%0x, " 
    472478                        L"%d bytes input)", key.ulID, algo, oData.Size()); 
    473479        return SignInternal(key, algo, oData, &Pin); 
  • middleware-offline/trunk/_src/eidmw/cardlayer/PkiCard.h

    r133 r145  
    7777 
    7878protected: 
    79     std::map <unsigned int, std::string> m_verifiedPINs; 
     79 
    8080 
    8181    virtual bool ShouldSelectApplet(unsigned char ins, unsigned long ulSW12); 
  • middleware-offline/trunk/_src/eidmw/common/Config.h

    r41 r145  
    138138#define EIDMW_CNF_GENERAL_CARDCONNDELAY L"card_connect_delay"   //number, delay before connecting to a smartcard, in mili-seconds, default 0 mSec 
    139139#define EIDMW_CNF_GENERAL_BUILDNBR              L"build_number"                 //Number of the installed build 
     140#define EIDMW_CNF_GENERAL_OTP_SERVER    L"otp_server" 
    140141 
    141142#define EIDMW_CNF_SECTION_LOGGING       L"logging"              //section with the logging parameters 
     
    275276    static const struct Param_Num EIDMW_CONFIG_PARAM_GENERAL_CARDCONNDELAY; 
    276277    static const struct Param_Num EIDMW_CONFIG_PARAM_GENERAL_BUILDNBR; 
     278    static const struct Param_Str EIDMW_CONFIG_PARAM_GENERAL_OTP_SERVER; 
    277279 
    278280    //LOGGING 
  • middleware-offline/trunk/_src/eidmw/common/ConfigCommon.cpp

    r133 r145  
    9898//AutoUpdates 
    9999  const struct CConfig::Param_Str CConfig::EIDMW_CONFIG_PARAM_AUTOUPDATES_URL      =       {EIDMW_CNF_SECTION_AUTOUPDATES, EIDMW_CNF_AUTOUPDATES_URL,          L""}; 
     100  const struct CConfig::Param_Str CConfig::EIDMW_CONFIG_PARAM_GENERAL_OTP_SERVER      =       {EIDMW_CNF_SECTION_GENERAL, EIDMW_CNF_GENERAL_OTP_SERVER, L"otp.cartaodecidadao.pt:443"}; 
    100101 
    101102} // namespace eidMW 
  • middleware-offline/trunk/_src/eidmw/common/eidErrors.h

    r124 r145  
    286286#define EIDMW_SOD_ERR_VERIFY_SOD_SIGN                           0xe1d00c08 
    287287 
     288#define EIDMW_OTP_CONNECTION_ERROR              0xe1d00d01 
     289#define EIDMW_OTP_PROTOCOL_ERROR                0xe1d00d02 
     290#define EIDMW_OTP_CERTIFICATE_ERROR             0xe1d00d03 
     291#define EIDMW_OTP_UNKNOWN_ERROR                 0xe1d00d04 
     292 
    288293// Errors in system calls 
    289294 
  • middleware-offline/trunk/_src/eidmw/dialogs/dialogsQTsrv/main.cpp

    r133 r145  
    766766        } 
    767767        while(fgets(buffer,sizeof(buffer),pF) != NULL){ 
    768                 sscanf(buffer,"%ld %ld %[^\n]\n",&pPid,&pPpid,pCommand); 
     768                sscanf(buffer,"%d %d %[^\n]\n",&pPid,&pPpid,pCommand); 
    769769                if(0 == strcmp(pCommand,CommandLineToFind)){ 
    770770                        pid=pPid; 
  • middleware-offline/trunk/_src/eidmw/eidgui/CardInformation.cpp

    r34 r145  
    3838        m_MiscInfo.Reset(); 
    3939        m_AddressInfo.Reset(); 
     40        m_PersoDataInfo.Reset(); 
    4041        m_pCard = NULL; 
    4142        m_cardReader = ""; 
     
    4647        bool bRetVal = false; 
    4748 
    48         Reset(); 
     49        //Reset(); 
    4950 
    5051        switch(Card.getType()) 
     
    6768        bool bRetVal = false; 
    6869 
    69         Reset(); 
     70        //Reset(); 
    7071 
    7172        switch(Card.getType()) 
     
    8889        bool bRetVal = false; 
    8990 
    90         Reset(); 
     91        //Reset(); 
    9192 
    9293        switch(Card.getType()) 
     
    109110        bool bRetVal = false; 
    110111 
    111         Reset(); 
     112        //Reset(); 
    112113 
    113114        switch(Card.getType()) 
     
    126127} 
    127128 
     129/* 
     130void LoadPinInfo(PTEID_EIDCard&    Card, QString const& cardReader ){ 
     131        PTEID_Pins& pins = Card.getPins(); 
     132 
     133        PTEID_Pin pin = pins.getPinByPinRef(PTEID_Pin::AUTH_PIN); 
     134        m_PinsInfo. 
     135        pins.getPinByPinRef(PTEID_Pin::SIGN_PIN); 
     136        pins.getPinByPinRef(PTEID_Pin::ADDR_PIN); 
     137 
     138} 
     139*/ 
     140 
     141 
     142 
     143 
  • middleware-offline/trunk/_src/eidmw/eidgui/dlgprint.cpp

    r133 r145  
    2121#include <QPixmap> 
    2222#include <QImage> 
     23#include <QString> 
    2324#include <cairo/cairo.h> 
    2425#include <cairo/cairo-pdf.h> 
     
    4344    if (CI_Data.isDataLoaded()) 
    4445    { 
    45                 ui.setupUi(this); 
     46        PTEID_EIDCard*  Card = dynamic_cast<PTEID_EIDCard*>(m_CI_Data.m_pCard); 
     47        ui.setupUi(this); 
    4648                setFixedSize(398, 245); 
    4749                const QIcon Ico = QIcon( ":/images/Images/Icons/Print.png" ); 
     
    6163                } 
    6264 
    63         try 
    64         { 
    65             unsigned long       ReaderStartIdx = 1; 
    66             bool                        bRefresh           = false; 
    67             unsigned long       ReaderEndIdx   = ReaderSet.readerCount(bRefresh); 
    68             unsigned long       ReaderIdx          = 0; 
    69  
    70             if (ReaderStartIdx!=(unsigned long)-1) 
    71             { 
    72                 ReaderEndIdx = ReaderStartIdx+1; 
    73             } 
    74             else 
    75             { 
    76                 ReaderStartIdx=0; 
    77             } 
    78  
    79             const char* readerName = ReaderSet.getReaderName(ReaderIdx); 
    80             m_CurrReaderName = readerName; 
    81             PTEID_ReaderContext &ReaderContext = ReaderSet.getReaderByName(m_CurrReaderName.toLatin1().data()); 
    82  
    83             if (ReaderContext.isCardPresent()) 
    84             { 
    85                 PTEID_EIDCard&  Card    = ReaderContext.getEIDCard(); 
    86                 CI_Data.LoadData(Card,m_CurrReaderName); 
    87             } 
    88         }       catch (PTEID_Exception &e) { 
    89             return; 
    90         } 
    91  
    92  
     65        CI_Data.LoadData(*Card,m_CurrReaderName); 
    9366    } 
    9467 
     
    160133} 
    161134 
     135//static cairo_status_t cairowriteQimageLst(void *closure, unsigned char const *data, unsigned int length); 
     136 
     137 
     138 
     139 
    162140void dlgPrint::on_pbPrint_clicked( void ) 
    163141{ 
    164142        CardInformation cdata = m_CI_Data; 
    165         QString defaultpngpath; 
    166  
    167         defaultpngpath = QDir::tempPath(); 
    168         defaultpngpath.append("/CartaoCidadao.png"); 
    169         drawpdf(cdata, PNG ,defaultpngpath.toStdString().c_str()); 
     143        imageList.clear(); 
     144 
     145        drawpdf(cdata, PNG , ""); 
    170146        QPrinter printer; 
    171147        QPrintDialog *dlg = new QPrintDialog(&printer,0); 
    172148        if(dlg->exec() == QDialog::Accepted) { 
    173                 QImage img (defaultpngpath); 
    174                 QPainter painter(&printer); 
    175                 painter.drawImage(QPoint(0,0),img); 
    176                 painter.end(); 
    177         } 
    178  
     149                QListIterator<QImage> i(imageList); 
     150                while (i.hasNext()){ 
     151                        QPainter painter(&printer); 
     152                        painter.drawImage(QPoint(0,0), i.next()); 
     153                        painter.end(); 
     154                } 
     155        } 
     156 
     157        delete dlg; 
    179158} 
    180159 
     
    253232} 
    254233 
    255 void dlgPrint::persodata_triggered(CardInformation& CI_Data) 
    256 { 
    257     try 
    258     { 
    259         unsigned long   ReaderStartIdx = 1; 
    260         bool                    bRefresh           = false; 
    261         unsigned long   ReaderEndIdx   = ReaderSet.readerCount(bRefresh); 
    262         unsigned long   ReaderIdx          = 0; 
    263  
    264         if (ReaderStartIdx!=(unsigned long)-1) 
    265         { 
    266             ReaderEndIdx = ReaderStartIdx+1; 
    267         } 
    268         else 
    269         { 
    270             ReaderStartIdx=0; 
    271         } 
    272  
    273         const char* readerName = ReaderSet.getReaderName(ReaderIdx); 
    274         m_CurrReaderName = readerName; 
    275         PTEID_ReaderContext &ReaderContext = ReaderSet.getReaderByName(m_CurrReaderName.toLatin1().data()); 
    276  
    277         if (ReaderContext.isCardPresent()) 
    278         { 
    279             PTEID_EIDCard&      Card    = ReaderContext.getEIDCard(); 
    280             CI_Data.LoadDataPersoData(Card,m_CurrReaderName); 
    281         } 
    282     }   catch (PTEID_Exception &e) { 
    283         QString msg(tr("General exception")); 
    284     } 
     234const char * dlgPrint::persodata_triggered() 
     235{ 
     236        try 
     237        { 
     238                PTEID_EIDCard*  Card = dynamic_cast<PTEID_EIDCard*>(m_CI_Data.m_pCard); 
     239 
     240                return Card->readPersonalNotes(); 
     241 
     242        }       catch (PTEID_Exception &e) { 
     243                QString msg(tr("General exception")); 
     244                return NULL; 
     245        } 
    285246} 
    286247 
    287248bool dlgPrint::addressPINRequest_triggered(CardInformation& CI_Data) 
    288249{ 
    289         //Workaround: Make PIN window called only one time 
    290         /*if (!m_CI_Data.isDataLoaded()) 
    291         { 
    292                 return true; 
    293         }*/ 
    294     try 
    295     { 
    296         PTEID_ReaderContext &ReaderContext = ReaderSet.getReaderByName(m_CurrReaderName.toLatin1().data()); 
    297  
    298         QString caption(tr("Identity Card: PIN verification")); 
    299  
    300         if (ReaderContext.isCardPresent()) 
    301         { 
    302             QString PinName = "PIN da Morada"; 
    303             PTEID_EIDCard&      Card    = ReaderContext.getEIDCard(); 
    304             PTEID_Pins&         Pins    = Card.getPins(); 
    305             for (unsigned long PinIdx=0; PinIdx<Pins.count(); PinIdx++) 
    306             { 
    307                 PTEID_Pin&      Pin                     = Pins.getPinByNumber(PinIdx); 
    308                 QString         CurrPinName     = Pin.getLabel(); 
    309  
    310                 if (CurrPinName==PinName) 
    311                 { 
    312                     unsigned long triesLeft = -1; 
    313                     bool                  bResult   = Pin.verifyPin("",triesLeft); 
    314                     //QString             msg(tr("PIN verification ")); 
    315  
    316                     QString msg = bResult ? tr("PIN verification passed"):tr("PIN verification failed"); 
    317                     if (!bResult) 
    318                     { 
    319                             QMessageBox::information( this, caption,  msg, QMessageBox::Ok ); 
    320                             return false; 
    321                     } 
    322                                         else 
    323                                         { 
    324                                          
    325                                                         CI_Data.LoadDataAddress(Card, m_CurrReaderName); 
    326                                  
     250        try 
     251        { 
     252                QString caption(tr("Identity Card: PIN verification")); 
     253 
     254                PTEID_EIDCard*  Card = dynamic_cast<PTEID_EIDCard*>(m_CI_Data.m_pCard); 
     255                PTEID_Pin&              Pin     = Card->getPins().getPinByPinRef(PTEID_Pin::ADDR_PIN); 
     256 
     257                unsigned long triesLeft = -1; 
     258                bool              bResult   = Pin.verifyPin("",triesLeft); 
     259                //QString                 msg(tr("PIN verification ")); 
     260 
     261                QString msg = bResult ? tr("PIN verification passed"):tr("PIN verification failed"); 
     262                QMessageBox::information( this, caption,  msg, QMessageBox::Ok ); 
     263                if (!bResult) 
     264                        return false; 
     265 
     266                CI_Data.LoadDataAddress(*Card, m_CurrReaderName); 
     267        } 
     268        catch (PTEID_Exception &e) 
     269        { 
     270                QString msg(tr("General exception")); 
     271                return false; 
     272        } 
     273        catch (...) 
     274        { 
     275                QString msg(tr("Unknown exception")); 
     276                return false; 
     277        } 
     278        return true; 
     279} 
     280 
     281 
     282double lineSize(cairo_t *ct, const QString &str){ 
     283        cairo_text_extents_t extents; 
     284 
     285        cairo_text_extents(ct,str.toUtf8(),&extents); 
     286        return extents.x_advance; 
     287} 
     288 
     289void formatLines(cairo_t *ct, const QString &str, QStringList &qSList){ 
     290        QString strTemp; 
     291        QString oldStrTemp; 
     292        QStringList lstTemp = str.split(QRegExp("\\s")); 
     293        int i=0; 
     294 
     295        if (lstTemp.size()>1){ 
     296                while (i<lstTemp.size()){ 
     297                        while (lineSize(ct,strTemp)<552 && i<lstTemp.size()){ 
     298                                oldStrTemp = strTemp; 
     299                                strTemp+=lstTemp.at(i++)+" "; 
     300                        } 
     301                        if (!oldStrTemp.isEmpty()){ 
     302                                qSList.append(oldStrTemp); 
     303                                oldStrTemp.clear(); 
     304                                if (i<lstTemp.size()) 
     305                                        strTemp = lstTemp.at(--i); 
     306                        } else { 
     307                                QString temp = strTemp; 
     308                                while(!temp.isEmpty()){ 
     309                                        int j=0; 
     310                                        while((temp.size()>=46+j) && lineSize(ct,temp.left(46+j))<552){ 
     311                                                j++; 
    327312                                        } 
    328                     QMessageBox::information( this, caption,  msg, QMessageBox::Ok ); 
    329                     break; 
    330                 } 
    331             } 
    332         } 
    333         else 
    334         { 
    335             QString msg(tr("No card present")); 
    336             QMessageBox::information( this, caption,  msg, QMessageBox::Ok ); 
    337             return false; 
    338         } 
    339     } 
    340     catch (PTEID_Exception &e) 
    341     { 
    342         QString msg(tr("General exception")); 
    343         return false; 
    344     } 
    345     catch (...) 
    346     { 
    347         QString msg(tr("Unknown exception")); 
    348         return false; 
    349     } 
    350     return true; 
    351 } 
    352  
    353 void dlgPrint::drawpdf(CardInformation& CI_Data, int format, const char *filepath) 
    354 { 
     313                                        qSList.append(temp.left(46+(j-1))); 
     314                                        if (temp.size()>=46+j){ 
     315                                                temp = temp.right(temp.size()-(46+(j-1))); 
     316                                        } else 
     317                                                temp.clear(); 
     318                                } 
     319                        } 
     320                } 
     321        } else { 
     322                QString temp = str; 
     323                while(!temp.isEmpty()){ 
     324                        int j=0; 
     325                        while((temp.size()>=46+j) && lineSize(ct,temp.left(46+j))<552) 
     326                                j++; 
     327                        qSList.append(temp.left(46+(j-1))); 
     328                        if (temp.size()>=46+j){ 
     329                                temp = temp.right(temp.size()-(46+(j-1))); 
     330                        } else 
     331                                temp.clear(); 
     332                } 
     333        } 
     334} 
     335 
     336 
     337void formatNotes(QString &personalNotes, cairo_t *ct, QStringList &qSList){ 
     338        personalNotes.replace("\t", "    "); 
     339        QStringList lines = personalNotes.split("\n"); 
     340 
     341        for (int i = 0; i < lines.size(); ++i){ 
     342                if (lineSize(ct, lines.at(i)) < 552) 
     343                        qSList.append(lines.at(i)); 
     344                else 
     345                        formatLines(ct, lines.at(i), qSList); 
     346        } 
     347} 
     348 
     349cairo_t *dlgPrint::createPage(int format, bool firstPage, const char *filepath, cairo_t *crt){ 
    355350        cairo_surface_t *surface; 
     351        cairo_surface_t *imagefront; 
     352        int w, h; 
    356353        cairo_t *cr; 
    357         cairo_surface_t *imagefront; 
    358         cairo_surface_t *idphoto; 
    359         int w, h; 
    360  
    361         //// Create pdf with cairo 
    362         if (format == PDF) 
    363         { 
    364                 surface = cairo_pdf_surface_create(filepath, 504, 648); 
    365         } else { 
    366                 //PNG 
    367                 surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 504, 648); 
    368         } 
    369  
    370         cr = cairo_create(surface); 
    371  
    372         //// Set Image - Front 
    373         QImage *qimg = new QImage (":/images/Images/application_print_PDF.png"); 
    374         imagefront = cairo_image_surface_create_for_data(qimg->bits(), CAIRO_FORMAT_RGB24, qimg->width(), qimg->height(), qimg->bytesPerLine()); 
     354 
     355        if (firstPage) 
     356                background = new QImage (":/images/Images/application_print_PDF.png"); 
     357        else 
     358                background = new QImage (":/images/Images/application_print_PDF_pg_2.png"); 
     359 
     360        if (format == PDF && firstPage) 
     361                        surface = cairo_pdf_surface_create(filepath, 504, 648); 
     362                else if (format == PNG) 
     363                        surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 504, 648); 
     364 
     365        if ((format == PDF && firstPage) || format == PNG) 
     366                cr = cairo_create(surface); 
     367        else 
     368                cr = crt; 
     369 
     370        imagefront = cairo_image_surface_create_for_data(background->bits(), CAIRO_FORMAT_RGB24, background->width(), background->height(), background->bytesPerLine()); 
    375371        w = cairo_image_surface_get_width (imagefront); 
    376372        h = cairo_image_surface_get_height (imagefront); 
    377373 
    378         cairo_scale (cr, 510.0/w, 650.0/h); 
     374        if ((format == PDF && firstPage) || format == PNG) 
     375                cairo_scale (cr, 510.0/w, 650.0/h); 
    379376 
    380377        cairo_set_source_surface(cr, imagefront, 0, 0); 
    381378        cairo_paint(cr); 
    382379 
    383  
    384         //// Set Text Entries //// 
    385380        cairo_select_font_face (cr, "Sans", CAIRO_FONT_SLANT_NORMAL, 
    386381                        CAIRO_FONT_WEIGHT_NORMAL); 
     
    388383        cairo_set_source_rgb(cr, 0, 0, 0); 
    389384 
     385        return cr; 
     386} 
     387 
     388 
     389static cairo_status_t write_png_stream_to_Qimage (void *in_closure, const unsigned char *data, 
     390                                                unsigned int length) 
     391{ 
     392        QByteArray *img = (QByteArray*) in_closure; 
     393 
     394        img->append((const char*)data, length); 
     395 
     396    return CAIRO_STATUS_SUCCESS; //CAIRO_STATUS_WRITE_ERROR 
     397} 
     398 
     399 
     400void dlgPrint::drawpdf(CardInformation& CI_Data, int format, const char *filepath) 
     401{ 
     402        cairo_t *cr; 
     403        cairo_surface_t *idphoto; 
     404        int w, h; 
     405 
     406        cr = createPage(format, true, filepath, NULL); 
     407 
    390408        tFieldMap& PersonFields = CI_Data.m_PersonInfo.getFields(); 
    391409        tFieldMap& CardFields = CI_Data.m_CardInfo.getFields(); 
     
    518536 
    519537                ////ADDRESS Abbr Building Type 
    520                 cairo_move_to(cr, 18.0, 380.0); 
     538                cairo_move_to(cr, 18.0, 630.0); 
    521539                cairo_show_text(cr, AddressFields[ADDRESS_ABBRBUILDINGTYPE].toStdString().c_str()); 
    522540 
    523541                ////ADDRESS Building Type 
    524                 cairo_move_to(cr, 18.0, 380.0); 
     542                cairo_move_to(cr, 230.0, 630.0); 
    525543                cairo_show_text(cr, AddressFields[ADDRESS_BUILDINGTYPE].toStdString().c_str()); 
    526544 
     
    538556 
    539557                ////ADDRESS Place 
    540                 cairo_move_to(cr, 30.0, 420.0); 
     558                cairo_move_to(cr, 430.0, 672.0); 
    541559                cairo_show_text(cr, AddressFields[ADDRESS_PLACE].toStdString().c_str()); 
    542560 
     
    559577        } 
    560578 
    561         if (ui.chboxPersoData->isChecked()) 
    562         { 
    563                 persodata_triggered(CI_Data); 
    564                 tFieldMap& PersoDataFields = CI_Data.m_PersoDataInfo.getFields(); 
    565  
    566                 ////PERSONAL NOTES 
    567                 cairo_move_to(cr, 20.0, 760.0); 
    568                 cairo_show_text(cr, (QString::fromUtf8(PersoDataFields[PERSODATA_INFO].toStdString().c_str())).toStdString().c_str()); 
    569         } 
    570  
    571579        if (ui.chboxID->isChecked()) 
    572580        { 
     581                cairo_save(cr); 
     582 
    573583                //Image 
    574584                img = QImage(); 
    575585                img.loadFromData(m_CI_Data.m_PersonInfo.m_BiometricInfo.m_pPictureData); 
    576                 QImage imgPicturescaled = img.scaled(150, 190); 
    577  
    578586 
    579587                idphoto = cairo_image_surface_create_for_data(img.bits(), CAIRO_FORMAT_RGB24, img.width(), 
    580                                                                                                         img.height(), img.bytesPerLine()); 
     588                                img.height(), img.bytesPerLine()); 
    581589 
    582590                int w2 = cairo_image_surface_get_width (idphoto); 
     
    587595                cairo_set_source_surface(cr, idphoto, 1050, 180); 
    588596                cairo_paint(cr); 
     597 
     598                cairo_restore(cr); 
     599        } 
     600 
     601        if (ui.chboxPersoData->isChecked()) 
     602        { 
     603                const char *notes = persodata_triggered(); 
     604                QString perso_data = QString::fromUtf8(notes); 
     605 
     606                // cairo_show_text() doesn't render linebreaks, at this time pango wasnt an alternative (strategies) 
     607                QStringList notesFormt; 
     608                formatNotes(perso_data,cr,notesFormt); 
     609                if (!notesFormt.isEmpty()){ 
     610                        int i=0; 
     611                        for (; i < notesFormt.size() && i < 5; ++i) 
     612                        { 
     613                                cairo_move_to(cr, 20.0, 760 + 15*i); 
     614                                cairo_show_text(cr, notesFormt.at(i).toUtf8()); 
     615                        } 
     616 
     617                        if (i<notesFormt.size()){ 
     618                                int firstLineYpos; 
     619                                for (; i<notesFormt.size(); i++){ 
     620                                        if ((i-5)%50 == 0){ 
     621                                                firstLineYpos = 90; 
     622                                                if (format == PDF){ 
     623                                                        cairo_show_page(cr); 
     624                                                } else { 
     625                                                        cairo_surface_write_to_png_stream (cairo_get_target(cr), write_png_stream_to_Qimage,&image); 
     626                                                        imageList.append(QImage::fromData(image)); 
     627                                                        image.clear(); 
     628                                                        cairo_surface_destroy(cairo_get_target(cr)); 
     629                                                        cairo_destroy(cr); 
     630                                                        delete background; 
     631                                                } 
     632                                                cr = createPage(format, false, NULL, cr); 
     633                                        } 
     634                                        cairo_move_to(cr, 20.0, firstLineYpos + 15*((i-5)%50)); 
     635                                        cairo_show_text(cr, notesFormt.at(i).toUtf8()); 
     636                                } 
     637                        } 
     638                } 
    589639        } 
    590640 
    591641        if (format == PDF) 
    592642        { 
    593                 //PDF Page 1 
    594643                cairo_show_page(cr); 
    595644        } else { 
    596                 //PNG write 
    597                 cairo_surface_write_to_png(surface, filepath); 
    598         } 
    599         cairo_surface_destroy(surface); 
     645                cairo_surface_write_to_png_stream (cairo_get_target(cr), write_png_stream_to_Qimage,&image); 
     646                imageList.append(QImage::fromData(image)); 
     647                image.clear(); 
     648        } 
     649 
     650        cairo_surface_destroy(cairo_get_target(cr)); 
    600651        cairo_destroy(cr); 
     652        delete background; 
    601653        return; 
    602654} 
     655 
     656 
    603657 
    604658 
  • middleware-offline/trunk/_src/eidmw/eidgui/dlgprint.h

    r77 r145  
    2626#include "genpur.h" 
    2727#include "CardInformation.h" 
     28#include <cairo/cairo.h> 
    2829 
    2930class dlgPrint : public QDialog 
     
    5253    QString                                     m_CurrReaderName;               //!< the current reader we're using 
    5354    QImage img; 
     55    QImage *background; 
     56    QList<QImage> imageList; 
     57    QByteArray image; 
    5458 
    5559    bool addressPINRequest_triggered(CardInformation& CI_Data); 
    56     void persodata_triggered(CardInformation& CI_Data); 
     60    const char * persodata_triggered(); 
    5761    void drawpdf(CardInformation& CI_Data, int format, const char *filepath); 
     62    cairo_t *createPage(int format, bool firstPage, const char *filepath, cairo_t *crt); 
    5863}; 
    5964 
  • middleware-offline/trunk/_src/eidmw/eidgui/dlgsignature.cpp

    r109 r145  
    3434#include "eidlib.h" 
    3535#include "mainwnd.h" 
     36 
     37#include "eidErrors.h" 
    3638 
    3739using namespace eIDMW; 
     
    156158void dlgSignature::on_pbSign_clicked ( void ) 
    157159{ 
     160        std::cout << "pb sign" << std::endl; 
    158161        QAbstractItemModel* model = view->model() ; 
    159162        QStringList strlist; 
     
    207210                savefilepath = QFileDialog::getSaveFileName(this, tr("Save File"),  
    208211                                nativedafaultpath, tr("Zip files 'XAdES' (*.zip)")); 
     212 
     213        if (savefilepath.isNull() || savefilepath.isEmpty()) 
     214                return; 
     215 
    209216        QString native_path = QDir::toNativeSeparators(savefilepath); 
    210217 
     
    255262    try 
    256263    { 
     264        std::cout << "run sign" << std::endl; 
    257265            PTEID_EIDCard*      Card = dynamic_cast<PTEID_EIDCard*>(m_CI_Data.m_pCard); 
    258266            PTEID_ByteArray SignXades; 
     
    263271 
    264272    } 
     273 
    265274    catch (PTEID_Exception &e) 
    266     { 
    267             ShowErrorMsgBox(); 
    268     } 
    269  
     275        { 
     276                switch(e.GetError()){ 
     277                case EIDMW_ERR_PIN_CANCEL: 
     278                        PTEID_LOG(PTEID_LOG_LEVEL_DEBUG, "eidgui", "PIN introduction - CANCELED!"); 
     279                        break; 
     280                case EIDMW_ERR_TIMEOUT: 
     281                        PTEID_LOG(PTEID_LOG_LEVEL_DEBUG, "eidgui", "PIN introduction - TIMEOUT!"); 
     282                        break; 
     283                default: 
     284                        PTEID_LOG(PTEID_LOG_LEVEL_DEBUG, "eidgui", "GENERAL EXCEPTION CAUGHT!"); 
     285                } 
     286        } 
    270287    return; 
    271288} 
    272289 
    273 void replace_lastdot_inplace(char* initial_file_path) 
    274 { 
    275         // We can only search forward because memrchr and strrchr  
    276         // are not available on Windows *sigh* 
    277         char ch = '.'; 
    278         char * pdest = NULL, *last_dot= NULL; 
    279         while ((pdest = strchr(initial_file_path, ch)) != NULL) 
    280              last_dot = pdest; 
    281         if (last_dot != NULL) 
    282                 *last_dot = '_'; 
    283 } 
    284  
    285  
    286  
    287 //XXX: output_path in this case should be a directory path 
     290 
    288291void dlgSignature::run_multiple_sign(const char ** paths, unsigned int n_paths, const char *output_path, bool timestamp) 
    289292{ 
     
    299302    } 
    300303    catch (PTEID_Exception &e) 
    301     { 
    302             ShowErrorMsgBox(); 
    303     } 
    304  
     304                { 
     305                        switch(e.GetError()){ 
     306                        case EIDMW_ERR_PIN_CANCEL: 
     307                                PTEID_LOG(PTEID_LOG_LEVEL_DEBUG, "eidgui", "PIN introduction - CANCELED!"); 
     308                                break; 
     309                        case EIDMW_ERR_TIMEOUT: 
     310                                PTEID_LOG(PTEID_LOG_LEVEL_DEBUG, "eidgui", "PIN introduction - TIMEOUT!"); 
     311                                break; 
     312                        default: 
     313                                PTEID_LOG(PTEID_LOG_LEVEL_DEBUG, "eidgui", "GENERAL EXCEPTION CAUGHT!"); 
     314                        } 
     315                } 
    305316    return; 
    306317} 
  • middleware-offline/trunk/_src/eidmw/eidgui/dlgverifysignature.cpp

    r109 r145  
    7878        nativedafaultpath = QDir::toNativeSeparators(getSignFile); 
    7979         
    80         sig_path_native = new char[nativedafaultpath.size()*2]; 
     80                sig_path_native = new char[nativedafaultpath.size()*2]; 
    8181        error = new char[errorlen]; 
    82         strcpy(sig_path_native, nativedafaultpath.toStdString().c_str()); 
     82                strcpy(sig_path_native, nativedafaultpath.toStdString().c_str()); 
    8383 
    8484        vsignsucess = vsign.VerifySignature(sig_path_native, error, &errorlen); 
     85                PTEID_LOG(PTEID_LOG_LEVEL_DEBUG, "eidgui",  
     86                                "Message received from VerifySignature() size=%d: %s", errorlen, error); 
    8587 
    86         if (vsignsucess) 
    87         { 
    88             QString msg = tr("Signature was successfully verified."); 
    89             // A quick hack, use the error message string buffer to get the timestamp out            
    90             if (errorlen > 0) 
    91             { 
    92                     msg += tr("\nTimestamp: "); 
    93                     msg += error; 
    94             } 
    95                      
    96             QMessageBox::information(this, tr("Verify Signature"), msg); 
     88                if (vsignsucess) 
     89                { 
     90                        QString msg = tr("Signature was successfully verified."); 
    9791 
    98             this->close(); 
     92                        if (errorlen > 0) 
     93                        { 
     94                                msg += QString("\n")+QString::fromAscii(error); 
     95                        } 
    9996 
    100         } 
    101         else 
    102         { 
    103                 PTEID_LOG(PTEID_LOG_LEVEL_DEBUG, "eidgui",  
    104                                 "Error message received from VerifySignature() size=%d: %s", errorlen, error); 
    105                 QMessageBox::critical(this, tr("Verify Signature"), QString::fromAscii(error, errorlen)); 
    106                 this->close(); 
     97                        QMessageBox::information(this, tr("Signature Validation"), msg); 
     98 
     99                        this->close(); 
     100 
     101                } 
     102                else 
     103                { 
     104 
     105                        QMessageBox::critical(this, tr("Signature Validation"), QString::fromAscii(error)); 
     106                        this->close(); 
     107                } 
    107108        } 
    108     } 
    109109} 
  • middleware-offline/trunk/_src/eidmw/eidgui/eidgui.qrc

    r34 r145  
    33        <file>Images/Background_IDBack.jpg</file> 
    44        <file>Images/Background_IDFront.jpg</file> 
    5         <file>Images/Female.png</file> 
    65        <file>Images/Icons/Chip.png</file> 
    76        <file>Images/Icons/Clear.png</file> 
     
    2019        <file>Images/Icons/reader_question.png</file> 
    2120        <file>Images/Icons/Help.png</file> 
    22         <file>Images/Male.png</file> 
    2321        <file>Images/a-z_identiteitskaart_logo.png</file> 
    24         <file>Images/schild_de.jpg</file> 
    25         <file>Images/schild_en.jpg</file> 
    26         <file>Images/schild_fr.jpg</file> 
    27         <file>Images/schild_nl.jpg</file> 
    2822        <file>Images/Page_background_Identity.png</file> 
    2923        <file>Images/bg-Blue.png</file> 
     
    4135        <file>Images/additional_data.png</file> 
    4236        <file>Images/application_print_PDF.png</file> 
     37        <file>Images/application_print_PDF_pg_2.png</file> 
    4338        <file>Images/bg-Light-Blue.png</file> 
    4439        <file>Images/bg_Empty.png</file> 
  • middleware-offline/trunk/_src/eidmw/eidgui/eidmw_nl.ts

    r133 r145  
    44<context> 
    55    <name>MainWnd</name> 
     6     <message> 
     7        <source>Bytes available:</source> 
     8        <translation>Bytes disponíveis:</translation> 
     9     </message> 
     10      <message> 
     11        <source>Certification path</source> 
     12        <translation>Caminho da certificação</translation> 
     13     </message> 
     14     <message> 
     15        <source>The certificates could not be validated, the certification path is not complete</source> 
     16        <translation>Os certificados não foram validados, o caminho de certificação não está completo</translation> 
     17</message> 
     18<message> 
     19        <source>Change Authentication and OTP PIN</source> 
     20        <translation>Alterar Pin de Autenticação e OTP</translation> 
     21</message> 
     22<message> 
     23        <source>Attention: your current authentication PIN will be requested twice in two different dialog boxes.</source> 
     24        <translation>Atenção: o seu actual PIN de autenticação vai ser requerido duas vezes neste processo.</translation> 
     25        </message> 
     26 
     27        <message> 
     28        <source>Sorry, this operation is unsupported on this reader</source> 
     29        <translation>Pedimos desculpa, mas esta operação não é suportada neste leitor de cartões</translation> 
     30</message> 
     31 
     32        <message> 
     33        <source>Verification of your current PIN failed</source> 
     34        <translation>O PIN actual está incorrecto.</translation> 
     35</message> 
     36<message> 
     37        <source>Error connecting to the OTP Server. Please check your internet connection.</source> 
     38        <translation>Erro na ligação ao servidor de OTP. Por favor certifica-se de que está ligado à Internet.</translation> 
     39</message> 
     40<message> 
     41        <source>Error connecting to the OTP Server. Your authentication certificate was rejected.</source> 
     42        <translation>Erro na ligação ao servidor de OTP. O seu certificado de autenticação foi rejeitado.</translation> 
     43</message> 
     44<message> 
     45        <source>Error connecting to the OTP Server. </source> 
     46        <translation>Erro na ligação ao servidor de OTP.</translation> 
     47</message> 
     48<message> 
     49        <source> Unexpected error in the OTP Server results. Aborting Pin change operation"</source> 
     50        <translation>Resultado inesperado recebido do servidor de OTP. Operação abortada.</translation> 
     51</message> 
     52<message> 
     53 
     54        <source>Error ocurred changing the authentication PIN. Please try again to avoid out-of-sync PINs</source> 
     55        <translation>Erro ocorrido na alteração de PIN de autenticação. Por favor tente outra vez para evitar ter PINs dessincronizados</translation> 
     56</message> 
     57     <message> 
     58        <source>%1 tries remaining</source> 
     59        <translation>Restam %1 tentativas</translation> 
     60     </message> 
     61     <message> 
     62        <source>%1 try remaining</source> 
     63        <translation>Resta %1 tentativa</translation> 
     64     </message> 
     65     <message> 
     66        <source>Reading card data...</source> 
     67        <translation>A ler os dados do cartão...</translation> 
     68    </message> 
     69     <message> 
     70        <source>Time for entering PIN expired (30 seconds)</source> 
     71        <translation>O tempo para introdução do PIN expirou (30 segundos)</translation> 
     72    </message> 
     73    <message> 
     74        <source>Save</source> 
     75        <translation>Gravar</translation> 
     76    </message> 
    677    <message> 
    778        <source>Warning</source> 
     
    1182        <source>A problem has occurred while trying to read card. Please, try again.</source> 
    1283        <translation type="unfinished">Ocorreu um erro ao tentar ler o cartão. Tente novamente por favor.</translation> 
     84    </message> 
     85    <message> 
     86        <source>The address cannot be accessed because the maximum number of PIN entry attempts has been reached</source> 
     87        <translation>Não foi possível aceder aos dados da morada porque o respectivo PIN está bloqueado</translation> 
     88    </message> 
     89    <message> 
     90        <source>Maximum number of PIN entry attempts has been reached! Couldn't save personal notes</source> 
     91        <translation>PIN da autenticação bloqueado. Não foi possível guardar as notas pessoais</translation> 
    1392    </message> 
    1493    <message> 
     
    739818    </message> 
    740819    <message> 
    741         <source>PIN change </source> 
    742         <translation type="unfinished">Alteração de PIN </translation> 
     820        <source>PIN change passed</source> 
     821        <translation type="unfinished">Alteração de PIN efectuada</translation> 
     822    </message> 
     823    <message> 
     824        <source>PIN change failed</source> 
     825        <translation type="unfinished">Alteração de PIN falhou</translation> 
    743826    </message> 
    744827    <message> 
     
    10291112    </message> 
    10301113    <message> 
    1031         <source>Cartao Inserido:</source> 
     1114        <source>Cartão Inserido:</source> 
    10321115        <translation type="unfinished"></translation> 
    10331116    </message> 
     
    10351118        <source>setEventCallbacks</source> 
    10361119        <translation type="unfinished"></translation> 
    1037     </message> 
    1038     <message> 
    1039         <source>Portuguese ID Card Management</source> 
    1040         <translation>Aplicação Oficial do Cartão de Cidadão Português</translation> 
    10411120    </message> 
    10421121</context> 
     
    10841163    <message> 
    10851164        <source>Do you want to check for updates?</source> 
    1086         <translation>Deseja verificar se existem actulizações disponiveis?</translation> 
     1165        <translation>Deseja verificar se existem actualizações disponíveis?</translation> 
    10871166    </message> 
    10881167</context> 
  • middleware-offline/trunk/_src/eidmw/eidgui/mainwnd.cpp

    r133 r145  
    4545#include "picturepopup.h" 
    4646#include "AutoUpdates.h" 
     47#include "eidErrors.h" 
     48#include "dialogs.h" 
     49#include "Util.h" 
     50#include <wchar.h> 
    4751#ifdef WIN32 
    4852#include <windows.h> 
     
    5963//State of Pin Notes 0->Right PIN 1->Not yet inserted or wrong PIN 
    6064static unsigned int pinNotes = 1 ; 
     65 
     66 
    6167 
    6268void MainWnd::createTrayMenu() 
     
    140146        setWindowFlags( flags ); 
    141147 
    142         list_of_pins[0] = PinInfo(1, "PIN da Autentica\xc3\xa7\xc3\xa3o"); 
    143         list_of_pins[1] = PinInfo(2, "PIN da Assinatura"); 
    144         list_of_pins[2] = PinInfo(3, "PIN da Morada"); 
    145          
    146  
    147  
    148148        /*** Setup progress Bar ***/ 
    149         m_progress = new QProgressDialog(); 
     149        m_progress = new QProgressDialog(this); 
     150        m_progress->setWindowModality(Qt::WindowModal); 
    150151        m_progress->setWindowTitle(QString::fromUtf8("Cart\xc3\xa3o de Cidad\xc3\xa3o")); 
    151         m_progress->setLabelText("Reading card data..."); 
    152  
     152        m_progress->setLabelText(tr("Reading card data...")); 
     153        m_progress->setWindowFlags(m_progress->windowFlags() ^ Qt::WindowMinimizeButtonHint ^ Qt::WindowCloseButtonHint ^ Qt::CustomizeWindowHint); 
     154        m_progress->setFixedSize(m_progress->size()); 
    153155        //Disable cancel button 
    154156        m_progress->setCancelButton(NULL); 
     
    157159        m_progress->setMaximum(0); 
    158160 
    159         m_progress->setWindowModality(Qt::WindowModal); 
    160161 
    161162        connect(&this->FutureWatcher, SIGNAL(finished()), m_progress, SLOT(cancel())); 
     
    263264                        pinactivate = 1; 
    264265                        pinNotes = 1; 
     266                        certdatastatus = 1; 
    265267                        m_connectionStatus = (PTEID_CertifStatus)-1; 
    266268                        m_CI_Data.Reset(); 
     
    388390{ 
    389391        m_ui.wdg_submenu_tools->setVisible(true); 
     392        //If defined language is portuguese, then the dialog needs to be larger 
    390393        if (m_Settings.getGuiLanguageCode() == GenPur::LANG_NL) 
    391394                m_ui.wdg_submenu_tools->setGeometry(128,4,146,110); 
     
    463466        { 
    464467                showNoReaderMsg(); 
    465  
    466                 if (m_Settings.getAutoCardReading()) 
     468                //If the application was started as minimized we need to load it once 
     469                if(!m_CI_Data.isDataLoaded()) 
    467470                { 
    468471                        loadCardData(); 
     
    676679                        m_msgBox = NULL; 
    677680                } 
    678         clearGuiContent(); 
     681        //clearGuiContent(); 
    679682                hide(); 
    680683                if(m_ShowBalloon) 
     
    690693 
    691694        //To avoid problem when restoring the eidgui and clears data 
    692         loadCardData(); 
     695        //loadCardData(); 
    693696        } 
    694697} 
     
    821824                        if( pCertContext ) 
    822825                        { 
     826                                if ( 0 == memcmp ( pCertContext->pCertInfo->Issuer.pbData, 
     827                                       pCertContext->pCertInfo->Subject.pbData, 
     828                                           pCertContext->pCertInfo->Subject.cbData 
     829                                           ) 
     830                                        ) 
     831                                        continue; 
    823832                                unsigned char KeyUsageBits = 0; // Intended key usage bits copied to here. 
    824833                                CertGetIntendedKeyUsage(X509_ASN_ENCODING, pCertContext->pCertInfo, &KeyUsageBits, 1); 
     
    893902        bool                    bImported       = false; 
    894903 
    895         QTreeWidgetItemIterator it(m_ui.treeCert); 
    896  
    897         while (*it)  
    898         { 
     904        QList<QTreeWidgetItem *> listItem = m_ui.treeCert->selectedItems(); 
     905        if (!listItem.isEmpty()){ 
     906 
     907                QTreeCertItem *item = dynamic_cast<QTreeCertItem *>(listItem.first()); 
     908 
     909                const PTEID_ByteArray certData = item->getCert()->getCertData(); 
     910                PTEID_ReaderContext& ReaderContext  = ReaderSet.getReaderByName(m_CurrReaderName.toLatin1().data()); 
     911                PTEID_EIDCard& Card     = ReaderContext.getEIDCard(); 
     912 
    899913                // ---------------------------------------------------- 
    900                 // only if certificate is selected, store it 
     914                // create the certificate context with the certificate raw data 
    901915                // ---------------------------------------------------- 
    902                 if ( (*it)->isSelected() ) 
    903                 { 
    904                         unsigned long CertIdx = getCertificateIndex( (*it)->text(0) ); 
    905  
    906                         if (CertIdx != -1) 
     916                pCertContext = CertCreateCertificateContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, certData.GetBytes(), certData.Size()); 
     917 
     918                if( pCertContext ) 
     919                { 
     920                        unsigned char KeyUsageBits = 0; // Intended key usage bits copied to here. 
     921                        CertGetIntendedKeyUsage(X509_ASN_ENCODING, pCertContext->pCertInfo, &KeyUsageBits, 1); 
     922 
     923                        // ---------------------------------------------------- 
     924                        // Only store the context of the certificates with usages for an end-user 
     925                        // ---------------------------------------------------- 
     926                        if((KeyUsageBits & CERT_KEY_CERT_SIGN_KEY_USAGE) == CERT_KEY_CERT_SIGN_KEY_USAGE) 
    907927                        { 
    908                                 PTEID_ReaderContext&  ReaderContext  = ReaderSet.getReaderByName(m_CurrReaderName.toLatin1().data()); 
    909                                 PTEID_EIDCard&           Card                   = ReaderContext.getEIDCard(); 
    910                                 PTEID_Certificates&      certificates   = Card.getCertificates(); 
    911                                 PTEID_Certificate&       cert                   = certificates.getCertFromCard(CertIdx); 
    912                                 const PTEID_ByteArray certData          = cert.getCertData(); 
    913  
    914                                 // ---------------------------------------------------- 
    915                                 // create the certificate context with the certificate raw data 
    916                                 // ---------------------------------------------------- 
    917                                 pCertContext = CertCreateCertificateContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, certData.GetBytes(), certData.Size()); 
    918  
    919                                 if( pCertContext ) 
     928                                if(StoreAuthorityCerts (pCertContext, KeyUsageBits, m_CurrReaderName.toLatin1().data())) 
    920929                                { 
    921                                         unsigned char KeyUsageBits = 0; // Intended key usage bits copied to here. 
    922                                         CertGetIntendedKeyUsage(X509_ASN_ENCODING, pCertContext->pCertInfo, &KeyUsageBits, 1); 
    923  
    924                                         // ---------------------------------------------------- 
    925                                         // Only store the context of the certificates with usages for an end-user  
    926                                         // ---------------------------------------------------- 
    927                                         if((KeyUsageBits & CERT_KEY_CERT_SIGN_KEY_USAGE) == CERT_KEY_CERT_SIGN_KEY_USAGE) 
     930                                        bImported = true; 
     931                                } 
     932                        } 
     933                        else 
     934                        { 
     935                                if(StoreUserCerts (Card, pCertContext, KeyUsageBits, (*item->getCert()), m_CurrReaderName.toLatin1().data())) 
     936                                { 
     937 
     938                                        //now store each time the issuer until we're done 
     939                                        // an exception is thrown when there is no issuer 
     940                                        bool bDone = false; 
     941                                        PTEID_Certificate* currCert = item->getCert(); 
     942                                        while(!bDone) 
    928943                                        { 
    929                                                 if(StoreAuthorityCerts (pCertContext, KeyUsageBits, m_CurrReaderName.toLatin1().data()))                      
     944                                                try 
    930945                                                { 
    931                                                         bImported = true; 
     946                                                        PTEID_Certificate*       issuer         = &currCert->getIssuer(); 
     947                                                        const PTEID_ByteArray certData  = issuer->getCertData(); 
     948 
     949                                                        pCertContext = CertCreateCertificateContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, certData.GetBytes(), certData.Size()); 
     950                                                        StoreAuthorityCerts (pCertContext, KeyUsageBits, m_CurrReaderName.toLatin1().data()); 
     951                                                        currCert         = issuer; 
     952                                                } 
     953                                                catch (PTEID_ExCertNoIssuer& e) 
     954                                                { 
     955                                                        long err = e.GetError(); 
     956                                                        err = err; 
     957                                                        // ok, we're at the end of the tree 
     958                                                        bDone = true; 
    932959                                                } 
    933960                                        } 
    934                                         else 
    935                                         { 
    936                                                 if(StoreUserCerts (Card, pCertContext, KeyUsageBits, cert, m_CurrReaderName.toLatin1().data())) 
    937                                                 { 
    938  
    939                                                         //now store each time the issuer until we're done 
    940                                                         // an exception is thrown when there is no issuer 
    941                                                         bool bDone = false; 
    942                                                         PTEID_Certificate* currCert = &cert; 
    943                                                         while(!bDone) 
    944                                                         { 
    945                                                                 try 
    946                                                                 { 
    947                                                                         PTEID_Certificate*       issuer         = &currCert->getIssuer(); 
    948                                                                         const PTEID_ByteArray certData  = issuer->getCertData(); 
    949  
    950                                                                         pCertContext = CertCreateCertificateContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, certData.GetBytes(), certData.Size()); 
    951                                                                         StoreAuthorityCerts (pCertContext, KeyUsageBits, m_CurrReaderName.toLatin1().data()); 
    952                                                                         currCert         = issuer; 
    953                                                                 } 
    954                                                                 catch (PTEID_ExCertNoIssuer& e) 
    955                                                                 { 
    956                                                                         long err = e.GetError(); 
    957                                                                         err = err; 
    958                                                                         // ok, we're at the end of the tree 
    959                                                                         bDone = true; 
    960                                                                 } 
    961                                                         } 
    962  
    963                                                         bImported = true; 
    964                                                 } 
    965                                         } 
    966                                         pCertContext = NULL; 
     961 
     962                                        bImported = true; 
    967963                                } 
    968                                 showCertImportMessage(bImported); 
    969964                        } 
    970                 } 
    971                 ++it; 
    972         } 
     965                        pCertContext = NULL; 
     966                } 
     967                showCertImportMessage(bImported); 
     968        } 
     969 
    973970        return bImported; 
    974971#else 
     
    12501247} 
    12511248 
    1252 //***************************************************** 
    1253 // get the index of a certificate starting from its label 
    1254 //***************************************************** 
    1255 unsigned long MainWnd::getCertificateIndex(QString const& CertLabel ) 
    1256 { 
    1257         try 
    1258         { 
    1259                 PTEID_ReaderContext &ReaderContext = ReaderSet.getReaderByName(m_CurrReaderName.toLatin1().data()); 
    1260  
    1261                 //------------------------------------ 
    1262                 // make always sure a card is present 
    1263                 //------------------------------------ 
    1264                 if (ReaderContext.isCardPresent()) 
    1265                 { 
    1266                         PTEID_EIDCard&          Card            = ReaderContext.getEIDCard(); 
    1267                         PTEID_Certificates&     certificates= Card.getCertificates(); 
    1268  
    1269                         //------------------------------------ 
    1270                         // find the certificate with this label 
    1271                         //------------------------------------ 
    1272                         for (unsigned long CertIdx=0; CertIdx<certificates.countFromCard(); CertIdx++) 
    1273                         { 
    1274                                 PTEID_Certificate&      cert                    = certificates.getCertFromCard(CertIdx); 
    1275                                 QString                         CurrCertLabel   = QString::fromUtf8(cert.getLabel()); 
    1276  
    1277                                 if (CurrCertLabel==CertLabel) 
    1278                                 { 
    1279                                         return CertIdx; 
    1280                                 } 
    1281                         } 
    1282                 } 
    1283         } 
    1284         catch (PTEID_Exception& e) 
    1285         { 
    1286                 unsigned long err = 0; 
    1287                 err = e.GetError(); 
    1288                 QString msg = tr("Card not present"); 
    1289         } 
    1290         return -1; 
    1291 } 
    1292  
    12931249//**************************************************** 
    12941250// Show certificate details (only for Windows) 
     
    12991255{ 
    13001256#if WIN32 
    1301         QTreeWidgetItemIterator it(m_ui.treeCert); 
    1302         while (*it)  
    1303         { 
    1304                 if ( (*it)->isSelected() ) 
    1305                 { 
    1306                         QString CertLabel = (*it)->text(0); 
    1307                         try 
    1308                         { 
    1309                                 PTEID_ReaderContext &ReaderContext = ReaderSet.getReaderByName(m_CurrReaderName.toLatin1().data()); 
    1310  
    1311                                 std::string ccimport = "Cartão de Cidadão 001"; 
    1312                                 QString qccimport = QString::fromUtf8(ccimport.c_str()); 
    1313  
    1314                                 //------------------------------------ 
    1315                                 // make always sure a card is present 
    1316                                 //------------------------------------ 
    1317                                 if (ReaderContext.isCardPresent()) 
    1318                                 { 
    1319                                         PTEID_EIDCard&          Card            = ReaderContext.getEIDCard(); 
    1320                                         PTEID_Certificates&     certificates= Card.getCertificates(); 
    1321                                  
    1322                                         //------------------------------------ 
    1323                                         // find the certificate with this label 
    1324                                         //------------------------------------ 
    1325                                         for (size_t CertIdx=0; CertIdx<certificates.countFromCard(); CertIdx++) 
    1326                                         { 
    1327                                                 PTEID_Certificate&      cert                    = certificates.getCertFromCard(CertIdx); 
    1328                                                 QString                         CurrCertLabel   = QString::fromUtf8(cert.getLabel()); 
    1329  
    1330                                                 if (CurrCertLabel==CertLabel) 
    1331                                                 { 
    1332  
    1333                                                         const PTEID_ByteArray certData = cert.getCertData(); 
    1334  
    1335                                                         CRYPTUI_VIEWCERTIFICATE_STRUCT tCert = {0}; 
    1336                                                         tCert.dwSize            = sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCT); 
    1337                                                         tCert.hwndParent        = this->winId(); 
    1338                                                         tCert.dwFlags           = CRYPTUI_DISABLE_EDITPROPERTIES; 
    1339                                                         tCert.pCertContext      = CertCreateCertificateContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, certData.GetBytes(), certData.Size()); 
    1340                                                         BOOL bChange            = FALSE; 
    1341                                                         CryptUIDlgViewCertificate(&tCert, &bChange); 
    1342                                                         CertFreeCertificateContext (tCert.pCertContext); 
    1343                                                 } 
    1344                                         } 
    1345                                          
    1346                                         if (CertLabel == "GTE CyberTrust Global Root") 
    1347                                         { 
    1348                                                         CRYPTUI_VIEWCERTIFICATE_STRUCT tCert = {0}; 
    1349                                                         tCert.dwSize            = sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCT); 
    1350                                                         tCert.hwndParent        = this->winId(); 
    1351                                                         tCert.dwFlags           = CRYPTUI_DISABLE_EDITPROPERTIES; 
    1352                                                         tCert.pCertContext      = CertCreateCertificateContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, (const BYTE*)certificates.getExternalCertData(1), (DWORD)certificates.getExternalCertDataSize(1)); 
    1353                                                         BOOL bChange            = FALSE; 
    1354                                                         CryptUIDlgViewCertificate(&tCert, &bChange); 
    1355                                                         CertFreeCertificateContext (tCert.pCertContext); 
    1356  
    1357                                         }  
    1358                                          
    1359                                         if (CertLabel == "ECRaizEstado") 
    1360                                         { 
    1361                                                         CRYPTUI_VIEWCERTIFICATE_STRUCT tCert = {0}; 
    1362                                                         tCert.dwSize            = sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCT); 
    1363                                                         tCert.hwndParent        = this->winId(); 
    1364                                                         tCert.dwFlags           = CRYPTUI_DISABLE_EDITPROPERTIES; 
    1365                                                         tCert.pCertContext      = CertCreateCertificateContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, (const BYTE*)certificates.getExternalCertData(2) , (DWORD)certificates.getExternalCertDataSize(2)); 
    1366                                                         BOOL bChange            = FALSE; 
    1367                                                         CryptUIDlgViewCertificate(&tCert, &bChange); 
    1368                                                         CertFreeCertificateContext (tCert.pCertContext); 
    1369  
    1370                                         }  
    1371  
    1372                                         if (CertLabel == qccimport)  
    1373                                         { 
    1374                                                         CRYPTUI_VIEWCERTIFICATE_STRUCT tCert = {0}; 
    1375                                                         tCert.dwSize            = sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCT); 
    1376                                                         tCert.hwndParent        = this->winId(); 
    1377                                                         tCert.dwFlags           = CRYPTUI_DISABLE_EDITPROPERTIES; 
    1378                                                         tCert.pCertContext      = CertCreateCertificateContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, (const BYTE*)certificates.getExternalCertData(3) , (DWORD)certificates.getExternalCertDataSize(3)); 
    1379                                                         BOOL bChange            = FALSE; 
    1380                                                         CryptUIDlgViewCertificate(&tCert, &bChange); 
    1381                                                         CertFreeCertificateContext (tCert.pCertContext); 
    1382                                         } 
    1383                                 } 
    1384                         } 
    1385                         catch (PTEID_Exception e) 
    1386                         { 
    1387  
    1388                         } 
    1389                 } 
    1390                 ++it; 
     1257        QList<QTreeWidgetItem *> listItem = m_ui.treeCert->selectedItems(); 
     1258        if (!listItem.isEmpty()){ 
     1259 
     1260                QTreeCertItem *item = dynamic_cast<QTreeCertItem *>(listItem.first()); 
     1261 
     1262                const PTEID_ByteArray certData = item->getCert()->getCertData(); 
     1263 
     1264                CRYPTUI_VIEWCERTIFICATE_STRUCT tCert = {0}; 
     1265                tCert.dwSize            = sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCT); 
     1266                tCert.hwndParent        = this->winId(); 
     1267                tCert.dwFlags           = CRYPTUI_DISABLE_EDITPROPERTIES; 
     1268                tCert.pCertContext      = CertCreateCertificateContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, certData.GetBytes(), certData.Size()); 
     1269                BOOL bChange            = FALSE; 
     1270                CryptUIDlgViewCertificate(&tCert, &bChange); 
     1271                CertFreeCertificateContext (tCert.pCertContext); 
    13911272        }  
    13921273#endif 
     
    14121293 
    14131294        QTreeCertItem* item=(QTreeCertItem*)baseItem; 
     1295 
    14141296        if (!m_CI_Data.isDataLoaded()) 
    1415         { 
    14161297                return; 
    1417         } 
     1298 
    14181299        PTEID_ReaderContext &ReaderContext = ReaderSet.getReaderByName(m_CurrReaderName.toLatin1().data()); 
    1419  
    1420         QString CertLabel = item->text(column); 
    14211300 
    14221301        //------------------------------------ 
     
    14491328                m_ui.btnCert_Details->setEnabled(true); 
    14501329        } 
    1451  
    14521330} 
    14531331 
     
    14661344 
    14671345        if (selectedItems.size()==1) 
    1468         { 
    14691346                on_treePIN_itemClicked((QTreeWidgetItem*)selectedItems[0], 0); 
    1470         } 
    1471  
    14721347} 
    14731348 
     
    14781353{ 
    14791354        if (!m_CI_Data.isDataLoaded()) 
    1480         { 
    14811355                return; 
    1482         } 
    1483         QString PinName = item->text(column); 
     1356 
     1357        int index = m_ui.treePIN->indexOfTopLevelItem(item); 
    14841358 
    14851359        PTEID_ReaderContext &ReaderContext = ReaderSet.getReaderByName(m_CurrReaderName.toLatin1().data()); 
    1486  
    1487         //------------------------------------ 
    1488         // make always sure a card is present 
    1489         //------------------------------------ 
    14901360        if (!ReaderContext.isCardPresent()) 
    1491         { 
    14921361                return; 
    1493         } 
     1362 
     1363 
     1364        /* BEGIN - the pin information have to be always sinchronized - quick fix 
     1365         * this chunk of code can be removed if in the future the pin information sinchronization requirement is dropped 
     1366         */ 
     1367        unsigned int _pinRef = item->data(0,Qt::UserRole).value<uint>(); 
    14941368        PTEID_EIDCard&  Card    = ReaderContext.getEIDCard(); 
    14951369        PTEID_Pins&             Pins    = Card.getPins(); 
    14961370 
    1497         //------------------------------------ 
    1498         // find the pin with this label 
    1499         //------------------------------------ 
    1500         for (unsigned long PinIdx=0; PinIdx<Pins.count(); PinIdx++) 
    1501         { 
    1502                 PTEID_Pin&      Pin                     = Pins.getPinByNumber(PinIdx); 
    1503                 QString         CurrPinName     = Pin.getLabel(); 
    1504  
    1505                 if ( CurrPinName == PinName.toUtf8().constData()) 
    1506                 { 
    1507                         QString PINId; 
    1508                         PINId = PINId.setNum(Pin.getId()); 
    1509                         QString PINStatus; 
    1510                         PINStatus.sprintf("Resta(m) %ld tentativa(s)", Pin.getTriesLeft()); 
    1511  
    1512                         //------------------------------------ 
    1513                         // fill in the fields 
    1514                         //------------------------------------ 
    1515                         m_ui.txtPIN_Name->setText(trUtf8(Pin.getLabel())); 
    1516                         m_ui.txtPIN_Name->setAccessibleName(CurrPinName); 
    1517                         m_ui.txtPIN_ID->setText(PINId); 
    1518                         m_ui.txtPIN_ID->setAccessibleName(PINId); 
    1519                         m_ui.txtPIN_Status->setText(PINStatus); 
    1520                         m_ui.txtPIN_Status->setAccessibleName(PINStatus); 
    1521                         setEnabledPinButtons(true); 
    1522  
    1523                         break; 
    1524                 } 
    1525         } 
     1371        PTEID_Pin& pin = Pins.getPinByPinRef(_pinRef); 
     1372        delete m_pinsInfo[_pinRef]; // doesn't make sense, but this way the quick fix can be removed with no harm 
     1373        m_pinsInfo[_pinRef] = new PinInfo(pin.getId(), pin.getLabel(), pin.getTriesLeft()); 
     1374        /* END - the pin information have to be always sinchronized */ 
     1375 
     1376 
     1377        unsigned int pinRef = item->data(0,Qt::UserRole).value<uint>(); 
     1378        PinInfo* pinfo = m_pinsInfo.find(pinRef)->second; 
     1379 
     1380        QString status; 
     1381        if (1 == pinfo->triesLeft) 
     1382                status = tr("%1 try remaining").arg(pinfo->triesLeft); 
     1383        else 
     1384                status = tr("%1 tries remaining").arg(pinfo->triesLeft); 
     1385        m_ui.txtPIN_Name->setText(pinfo->pin_name); 
     1386        m_ui.txtPIN_Name->setAccessibleName(pinfo->pin_name); 
     1387        m_ui.txtPIN_ID->setText(pinfo->pin_id); 
     1388        m_ui.txtPIN_ID->setAccessibleName(pinfo->pin_id); 
     1389        m_ui.txtPIN_Status->setText(status); 
     1390        m_ui.txtPIN_Status->setAccessibleName(status); 
     1391        setEnabledPinButtons(pinfo->triesLeft > 0); 
    15261392} 
    15271393 
     
    21412007void MainWnd::loadCardDataCertificates( void ) 
    21422008{ 
    2143     if (!m_CI_Data.isDataLoaded()) 
    2144         return; 
     2009   
    21452010        //---------------------------------------------------------------- 
    21462011        // if we load a new card, clear the certificate contexts we kept 
     
    24422307{ 
    24432308        if (!m_CI_Data.isDataLoaded()) 
    2444         { 
    24452309                return; 
    2446         } 
     2310 
    24472311        try 
    24482312        { 
    24492313                PTEID_ReaderContext &ReaderContext = ReaderSet.getReaderByName(m_CurrReaderName.toLatin1().data()); 
    2450  
    2451                 //------------------------------------ 
    2452                 // make always sure a card is present 
    2453                 //------------------------------------ 
    2454                 QString           caption(tr("Identity Card: PIN verification")); 
     2314                QString caption(tr("Identity Card: PIN verification")); 
     2315                QString msg; 
    24552316 
    24562317                if (ReaderContext.isCardPresent()) 
    24572318                { 
    2458                         //QString PinName = m_ui.txtPIN_Name->text(); 
    2459                         QString PinName = "PIN da Autenticação"; 
    2460                         if (PinName.length()==0) 
     2319                        PTEID_Pin &pin = ReaderContext.getEIDCard().getPins().getPinByPinRef(PTEID_Pin::AUTH_PIN); 
     2320 
     2321                        if (pin.getTriesLeft() == 0) 
    24612322                        { 
    2462                                 //-------------------------- 
    2463                                 // no pin selected in tree 
    2464                                 //-------------------------- 
     2323                                QString msg = tr("Maximum number of" 
     2324                                                " PIN entry attempts has been reached! Couldn't save personal notes"); 
     2325 
     2326                                QMessageBox::critical(this, caption,  msg, QMessageBox::Ok); 
    24652327                                return; 
    24662328                        } 
    24672329 
    2468                         PTEID_EIDCard&  Card    = ReaderContext.getEIDCard(); 
    2469                         PTEID_Pins&             Pins    = Card.getPins(); 
    2470  
    2471                         for (unsigned long PinIdx=0; PinIdx<Pins.count(); PinIdx++) 
    2472                         { 
    2473                                 PTEID_Pin&      Pin                     = Pins.getPinByNumber(PinIdx); 
    2474                                 QString         CurrPinName     = Pin.getLabel(); 
    2475  
    2476                                 if (CurrPinName==PinName) 
    2477                                 { 
    2478                                         unsigned long triesLeft = -1; 
    2479                                         bool              bResult   = Pin.verifyPin("",triesLeft); 
    2480                                         //QString                 msg(tr("PIN verification ")); 
    2481  
    2482                                         QString msg = bResult?tr("PIN verification passed"):tr("PIN verification failed"); 
    2483                                         if (!bResult) 
    2484                                         { 
    2485                                                 //-------------------------- 
    2486                                                 // if it remains to -1, then CANCEL was pressed 
    2487                                                 // so, don't give a message 
    2488                                                 //-------------------------- 
    2489                                                 if ((unsigned long)-1!=triesLeft) 
    2490                                                 { 
    2491                                                         QString nrTriesLeft; 
    2492                                                         nrTriesLeft.setNum(triesLeft); 
    2493                                                         msg += "\n"; 
    2494                                                         msg += "( "; 
    2495                                                         msg += tr("Number of tries left: ") + nrTriesLeft + " )"; 
    2496                                                 } 
    2497                                                 else 
    2498                                                 { 
    2499                                                         break; 
    2500                                                 } 
    2501                                         }else{ 
    2502                                                 pinNotes=0; 
    2503                                         } 
    2504                                         QMessageBox::information( this, caption,  msg, QMessageBox::Ok ); 
    2505                                         break; 
    2506                                 } 
     2330                        unsigned long triesLeft = -1; 
     2331                        bool bResult   = pin.verifyPin("",triesLeft); 
     2332 
     2333                        if (!bResult && -1 == triesLeft) 
     2334                                return; 
     2335 
     2336                        m_pinsInfo.find(PTEID_Pin::AUTH_PIN)->second->triesLeft = triesLeft; 
     2337 
     2338                        QString status; 
     2339                        if (1 == triesLeft) 
     2340                                status = tr("%1 try remaining").arg(triesLeft); 
     2341                        else 
     2342                                status = tr("%1 tries remaining").arg(triesLeft); 
     2343 
     2344                        if (bResult){ 
     2345                                pinNotes=0; 
     2346                        } else { 
     2347                                msg = tr("PIN verification failed"); 
     2348                                msg += "\n"; 
     2349                                msg += status; 
    25072350                        } 
    25082351                } 
    25092352                else 
    2510                 { 
    2511                         QString msg(tr("No card present")); 
     2353                        msg = tr("No card present"); 
     2354 
     2355                if (!msg.isEmpty()) 
    25122356                        QMessageBox::information( this, caption,  msg, QMessageBox::Ok ); 
    2513                 } 
    25142357        } 
    25152358        catch (PTEID_Exception &e) 
    25162359        { 
    2517                 QString msg(tr("General exception")); 
     2360                QString msg; 
     2361 
     2362                switch(e.GetError()){ 
     2363                case EIDMW_ERR_PIN_CANCEL: 
     2364                        // show nothing user pressed cancel. 
     2365                        return; 
     2366                case EIDMW_ERR_TIMEOUT: 
     2367                        msg = tr("Time for entering PIN expired (30 seconds)"); 
     2368                        break; 
     2369                default: 
     2370                        msg = tr("General exception"); 
     2371                } 
    25182372                ShowPTEIDError( e.GetError(), msg ); 
    25192373        } 
     
    25342388        { 
    25352389                PTEID_ReaderContext &ReaderContext = ReaderSet.getReaderByName(m_CurrReaderName.toLatin1().data()); 
    2536                  
     2390 
    25372391                QString caption(tr("Identity Card: PIN verification")); 
    2538                  
     2392                QString msg; 
     2393 
    25392394                if (ReaderContext.isCardPresent()) 
    25402395                { 
    2541                         QString PinName = "PIN da Morada"; 
    2542                         PTEID_EIDCard&  Card    = ReaderContext.getEIDCard(); 
    2543                         PTEID_Pins&             Pins    = Card.getPins(); 
    2544                         for (unsigned long PinIdx=0; PinIdx<Pins.count(); PinIdx++) 
     2396                        PTEID_Pin &pin = ReaderContext.getEIDCard().getPins().getPinByPinRef(PTEID_Pin::ADDR_PIN); 
     2397 
     2398                        if (pin.getTriesLeft() == 0) 
    25452399                        { 
    2546                                 PTEID_Pin&      Pin                     = Pins.getPinByNumber(PinIdx); 
    2547                                 QString         CurrPinName     = Pin.getLabel(); 
    2548  
    2549                                 if (CurrPinName==PinName) 
    2550                                 { 
    2551                                         unsigned long triesLeft = -1; 
    2552                                         bool              bResult   = Pin.verifyPin("",triesLeft); 
    2553                                         //QString                 msg(tr("PIN verification ")); 
    2554  
    2555                                         QString msg = bResult ? tr("PIN verification passed"):tr("PIN verification failed"); 
    2556                                         if (!bResult) 
    2557                                         { 
    2558                                                         pinactivate = 1; 
    2559                                                         QMessageBox::information( this, caption,  msg, QMessageBox::Ok ); 
    2560                                                         return false; 
    2561                                         } 
    2562                                         else 
    2563                                         { 
    2564                                                 pinactivate = 0; 
    2565                                         } 
    2566                                         QMessageBox::information( this, caption,  msg, QMessageBox::Ok ); 
    2567                                         break; 
    2568                                 } 
     2400                                QString msg = tr("The address cannot be accessed because the maximum number of" 
     2401                                        " PIN entry attempts has been reached"); 
     2402 
     2403                                QMessageBox::critical(this, caption,  msg, QMessageBox::Ok); 
     2404                                return false; 
    25692405                        } 
     2406 
     2407                        unsigned long triesLeft = -1; 
     2408                        bool bResult   = pin.verifyPin("",triesLeft); 
     2409 
     2410                        if (!bResult && -1 == triesLeft) 
     2411                                return false; 
     2412 
     2413                        m_pinsInfo.find(PTEID_Pin::ADDR_PIN)->second->triesLeft = triesLeft; 
     2414 
     2415                        QString status; 
     2416                        if (1 == triesLeft) 
     2417                                status = tr("%1 try remaining").arg(triesLeft); 
     2418                        else 
     2419                                status = tr("%1 tries remaining").arg(triesLeft); 
     2420 
     2421                        if (bResult){ 
     2422                                pinactivate = 0; 
     2423                        } else { 
     2424                                msg = tr("PIN verification failed"); 
     2425                                msg += "\n"; 
     2426                                msg += status; 
     2427                                pinactivate = 1; 
     2428                        } 
    25702429                } 
    25712430                else 
    2572                 { 
    2573                         QString msg(tr("No card present")); 
     2431                        msg = tr("No card present"); 
     2432 
     2433                if (!msg.isEmpty()) 
    25742434                        QMessageBox::information( this, caption,  msg, QMessageBox::Ok ); 
     2435                return pinactivate == 0; 
     2436        } 
     2437        catch (PTEID_Exception &e) 
     2438        { 
     2439                QString msg; 
     2440 
     2441                switch(e.GetError()){ 
     2442                case EIDMW_ERR_PIN_CANCEL: 
     2443                        // show nothing user pressed cancel. 
    25752444                        return false; 
    2576                 } 
    2577         } 
    2578         catch (PTEID_Exception &e) 
    2579         { 
    2580                 QString msg(tr("General exception")); 
    2581                 ShowPTEIDError( e.GetError(), msg ); 
     2445                case EIDMW_ERR_TIMEOUT: 
     2446                        msg = tr("Time for entering PIN expired (30 seconds)"); 
     2447                        break; 
     2448                default: 
     2449                        msg = tr("General exception"); 
     2450                } 
     2451                ShowPTEIDError( e.GetError(), msg ); 
     2452 
    25822453                return false; 
    25832454        } 
     
    25882459                return false; 
    25892460        } 
    2590         return true; 
    25912461} 
    25922462 
     
    25972467{ 
    25982468        if (!m_CI_Data.isDataLoaded()) 
    2599         { 
    26002469                return; 
    2601         } 
     2470 
    26022471        try 
    26032472        { 
    26042473                PTEID_ReaderContext &ReaderContext = ReaderSet.getReaderByName(m_CurrReaderName.toLatin1().data()); 
    26052474                QString          caption(tr("Identity Card: PIN verification")); 
     2475                QString msg; 
    26062476 
    26072477                if (ReaderContext.isCardPresent()) 
    26082478                { 
    2609                         QString PinNameRaw = m_ui.txtPIN_Name->text(); 
    2610                         QString PinName = PinNameRaw.toUtf8().constData(); 
    2611  
    2612                         if (PinName.length()==0) 
     2479                        QTreeWidgetItem *item = m_ui.treePIN->currentItem(); 
     2480 
     2481                        if (!item) 
     2482                                return; 
     2483 
     2484                        unsigned int pinRef = item->data(0,Qt::UserRole).value<uint>(); 
     2485                        PTEID_Pin &pin = ReaderContext.getEIDCard().getPins().getPinByPinRef(pinRef); 
     2486 
     2487                        unsigned long triesLeft = -1; 
     2488                        bool bResult   = pin.verifyPin("",triesLeft); 
     2489 
     2490                        if (!bResult && -1 == triesLeft) 
     2491                                return; 
     2492 
     2493                        m_pinsInfo.find(pinRef)->second->triesLeft = triesLeft; 
     2494 
     2495                        QString status; 
     2496                        if (1 == triesLeft) 
     2497                                status = tr("%1 try remaining").arg(triesLeft); 
     2498                        else 
     2499                                status = tr("%1 tries remaining").arg(triesLeft); 
     2500 
     2501                        if (bResult){ 
     2502                                msg = tr("PIN verification passed"); 
     2503                        } else { 
     2504                                msg = tr("PIN verification failed"); 
     2505                                msg += "\n"; 
     2506                                msg += status; 
     2507                        } 
     2508 
     2509                        m_ui.txtPIN_Status->setText(status); 
     2510                        m_ui.txtPIN_Status->setAccessibleName(status); 
     2511                } 
     2512                else 
     2513                        msg = tr("No card present"); 
     2514 
     2515                QMessageBox::information( this, caption,  msg, QMessageBox::Ok ); 
     2516        } 
     2517        catch (PTEID_Exception &e) 
     2518        { 
     2519                QString msg; 
     2520 
     2521                switch(e.GetError()){ 
     2522                case EIDMW_ERR_PIN_CANCEL: 
     2523                        // show nothing user pressed cancel. 
     2524                        return; 
     2525                case EIDMW_ERR_TIMEOUT: 
     2526                        msg = tr("Time for entering PIN expired (30 seconds)"); 
     2527                        break; 
     2528                default: 
     2529                        msg = tr("General exception"); 
     2530                } 
     2531                ShowPTEIDError( e.GetError(), msg ); 
     2532        } 
     2533        catch (...) 
     2534        { 
     2535                QString msg(tr("Unknown exception")); 
     2536                ShowPTEIDError( 0, msg ); 
     2537        } 
     2538        return; 
     2539} 
     2540 
     2541void MainWnd::ChangeAuthPin(PTEID_ReaderContext &ReaderContext, unsigned int pin_ref) 
     2542{ 
     2543 
     2544        PTEID_EIDCard &card = ReaderContext.getEIDCard(); 
     2545        //Show AskPins dialogs 
     2546        PTEID_Pin &pin = card.getPins().getPinByPinRef(pin_ref); 
     2547        bool bResult = false;  
     2548        bool verify_ret = false;  
     2549        wchar_t wsPin1[PIN_MAX_LENGTH+1]; 
     2550        wchar_t wsPin2[PIN_MAX_LENGTH+1]; 
     2551        char old_pin[PIN_MAX_LENGTH+1]; 
     2552        char new_pin[PIN_MAX_LENGTH+1]; 
     2553        QString dialog_title(tr("Change Authentication and OTP PIN")); 
     2554 
     2555        //Some Way to detect pinpads to show different message 
     2556        QString msg(tr("Attention: your current authentication PIN will be requested twice " 
     2557                                "in two different dialog boxes.")); 
     2558        QMessageBox msgBoxcc(QMessageBox::Information, dialog_title, msg, 0, this); 
     2559        msgBoxcc.setModal(true); 
     2560        msgBoxcc.exec(); 
     2561 
     2562        DlgPinInfo pinInfo = {4, 8, PIN_FLAG_DIGITS}; 
     2563 
     2564        DlgRet ret = DlgAskPins(DLG_PIN_OP_CHANGE, 
     2565                        DLG_PIN_AUTH, L"Pin de Autenticação", 
     2566                        pinInfo, wsPin1,PIN_MAX_LENGTH+1,  
     2567                pinInfo, wsPin2,PIN_MAX_LENGTH+1); 
     2568 
     2569        if (ret == DLG_OK) 
     2570        { 
     2571                strcpy(old_pin, utilStringNarrow(std::wstring(wsPin1)).c_str()); 
     2572                strcpy(new_pin, utilStringNarrow(std::wstring(wsPin2)).c_str()); 
     2573        }  
     2574        else 
     2575           return;       
     2576         
     2577        // Perform a verifyPin with no interaction (to rule out pinpad readers like Xiring) 
     2578        // and abort if wrong/blocked/not supported 
     2579        unsigned long triesLeft = -1; 
     2580        try 
     2581        { 
     2582                verify_ret = pin.verifyPin(old_pin, 
     2583                                triesLeft, false); 
     2584        } 
     2585        catch (PTEID_Exception &ex) 
     2586        { 
     2587                if (strstr(m_CurrReaderName.toLatin1().data(), "Xiring")!= NULL) 
     2588                { 
     2589                        QString pinpad_msg(tr("Sorry, this operation is unsupported on this reader")); 
     2590 
     2591                        QMessageBox msgBoxcc(QMessageBox::Critical, dialog_title, pinpad_msg, 0, this); 
     2592                        msgBoxcc.setModal(true) ; 
     2593                        msgBoxcc.exec(); 
     2594                        return; 
     2595                } 
     2596 
     2597        } 
     2598 
     2599        if (!verify_ret) 
     2600        { 
     2601                 
     2602                //Some Way to detect pinpads to show different message 
     2603                QString msg(tr("Verification of your current PIN failed")); 
     2604                QMessageBox msgBoxcc(QMessageBox::Critical, dialog_title, msg, 0, this); 
     2605                msgBoxcc.setModal(true) ; 
     2606                msgBoxcc.exec(); 
     2607 
     2608                return; 
     2609        } 
     2610         
     2611        //Call ChangeCapPin 
     2612        try 
     2613        { 
     2614 
     2615            card.ChangeCapPin(new_pin); 
     2616 
     2617        } 
     2618        catch(PTEID_Exception &ex) 
     2619        { 
     2620                QString msg = ""; 
     2621                switch(ex.GetError()) 
     2622                { 
     2623                        case EIDMW_OTP_CONNECTION_ERROR: 
     2624                        msg = tr("Error connecting to the OTP Server. Please check your internet connection."); 
     2625                        break; 
     2626                        case EIDMW_OTP_PROTOCOL_ERROR: 
     2627                        msg = tr("Unexpected error in the OTP Server results. Aborting Pin change operation"); 
     2628                        break; 
     2629                        case EIDMW_OTP_CERTIFICATE_ERROR: 
     2630                        msg = tr("Error connecting to the OTP Server. Your authentication certificate was rejected"); 
     2631                        case EIDMW_OTP_UNKNOWN_ERROR: 
     2632                        msg = tr("Error connecting to the OTP Server."); 
     2633                        break; 
     2634                default: 
     2635                        msg = tr("General exception"); 
     2636                } 
     2637 
     2638                ShowPTEIDError( ex.GetError(), msg ); 
     2639                return; 
     2640        } 
     2641         
     2642        try 
     2643        { 
     2644                // Actually change the Auth Pin with no interaction 
     2645                bResult = pin.changePin(old_pin, new_pin, triesLeft, pin.getLabel()); 
     2646        } 
     2647        catch(PTEID_Exception &ex) 
     2648        { 
     2649 
     2650                QString msg(tr("Error ocurred changing the authentication PIN. " 
     2651                                "Please try again to avoid out-of-sync PINs")); 
     2652                QMessageBox msgBoxcc(QMessageBox::Warning, dialog_title, msg, 0, this); 
     2653                msgBoxcc.setModal(true) ; 
     2654                msgBoxcc.exec(); 
     2655                return; 
     2656 
     2657        } 
     2658        if (!bResult && -1 == triesLeft) 
     2659        { 
     2660        //TODO: another error msg 
     2661            return; 
     2662 
     2663        } 
     2664         
     2665        QMessageBox::information( this, dialog_title,  QString(tr("Pin Change passed")), QMessageBox::Ok ); 
     2666 
     2667 
     2668} 
     2669 
     2670//***************************************************** 
     2671// PIN change button clicked 
     2672//***************************************************** 
     2673void MainWnd::on_actionPINChange_triggered() 
     2674{ 
     2675        if (!m_CI_Data.isDataLoaded()) 
     2676        { 
     2677                return; 
     2678        } 
     2679        try 
     2680        { 
     2681                PTEID_ReaderContext &ReaderContext = ReaderSet.getReaderByName(m_CurrReaderName.toLatin1().data()); 
     2682                QString caption(tr("Identity Card: PIN change")); 
     2683                QString msg; 
     2684 
     2685                if (ReaderContext.isCardPresent()) 
     2686                { 
     2687                        QTreeWidgetItem *item = m_ui.treePIN->currentItem(); 
     2688 
     2689                        if (!item) 
     2690                                return; 
     2691 
     2692                        unsigned int pinRef = item->data(0,Qt::UserRole).value<uint>(); 
     2693                        if (pinRef == 0x01 || pinRef == 0x81) 
    26132694                        { 
    2614                                 //-------------------------- 
    2615                                 // no pin selected in tree 
    2616                                 //-------------------------- 
     2695                                ChangeAuthPin(ReaderContext, pinRef); 
    26172696                                return; 
    26182697                        } 
    2619  
    2620                         PTEID_EIDCard&  Card    = ReaderContext.getEIDCard(); 
    2621                         PTEID_Pins&             Pins    = Card.getPins(); 
    2622  
    2623                         for (unsigned long PinIdx=0; PinIdx<Pins.count(); PinIdx++) 
    2624                         { 
    2625                                 PTEID_Pin&      Pin                     = Pins.getPinByNumber(PinIdx); 
    2626                                 QString         CurrPinName     = Pin.getLabel(); 
    2627  
    2628                                 if (CurrPinName==PinName) 
    2629                                 { 
    2630                                         unsigned long triesLeft = -1; 
    2631                                         bool              bResult   = Pin.verifyPin("",triesLeft); 
    2632                                         //QString                 msg(tr("PIN verification ")); 
    2633  
    2634                                         QString msg = bResult?tr("PIN verification passed"):tr("PIN verification failed"); 
    2635                                         if (!bResult) 
    2636                                         { 
    2637                                                 //-------------------------- 
    2638                                                 // if it remains to -1, then CANCEL was pressed 
    2639                                                 // so, don't give a message 
    2640                                                 //-------------------------- 
    2641                                                 if ((unsigned long)-1!=triesLeft) 
    2642                                                 { 
    2643                                                         QString nrTriesLeft; 
    2644                                                         nrTriesLeft.setNum(triesLeft); 
    2645                                                         msg += "\n"; 
    2646                                                         msg += "( "; 
    2647                                                         msg += tr("Resta(m) ") + nrTriesLeft + " tentativas)"; 
    2648                                                         m_ui.txtPIN_Status->setText(msg); 
    2649                                                         m_ui.txtPIN_Status->setAccessibleName(msg); 
    2650                                                 } 
    2651                                                 else 
    2652                                                 { 
    2653                                                         break; 
    2654                                                 } 
    2655                                         } 
    2656                                         else 
    2657                                         { 
    2658                                                 QString nrTriesLeft; 
    2659                                                 nrTriesLeft.setNum(triesLeft); 
    2660                                                 m_ui.txtPIN_Status->setText("Resta(m) 3 tentativas"); 
    2661                                                 m_ui.txtPIN_Status->setAccessibleName("Resta(m) 3 tentativas"); 
    2662                                         } 
    2663                                         QMessageBox::information( this, caption,  msg, QMessageBox::Ok ); 
    2664                                         break; 
    2665                                 } 
     2698                        PTEID_Pin &pin = ReaderContext.getEIDCard().getPins().getPinByPinRef(pinRef); 
     2699 
     2700                        unsigned long triesLeft = -1; 
     2701                        bool bResult = pin.changePin("","",triesLeft, pin.getLabel()); 
     2702 
     2703                        if (!bResult && -1 == triesLeft) 
     2704                                return; 
     2705 
     2706                        m_pinsInfo.find(pinRef)->second->triesLeft = triesLeft; 
     2707 
     2708                        QString status; 
     2709                        if (1 == triesLeft) 
     2710                                status = tr("%1 try remaining").arg(triesLeft); 
     2711                        else 
     2712                                status = tr("%1 tries remaining").arg(triesLeft); 
     2713 
     2714                        if (bResult){ 
     2715                                msg = tr("PIN change passed"); 
     2716                        } else { 
     2717                                msg = tr("PIN change failed"); 
     2718                                msg += "\n"; 
     2719                                msg += status; 
    26662720                        } 
     2721 
     2722                        m_ui.txtPIN_Status->setText(status); 
     2723                        m_ui.txtPIN_Status->setAccessibleName(status); 
    26672724                } 
    26682725                else 
    2669                 { 
    2670                         QString msg(tr("No card present")); 
    2671                         QMessageBox::information( this, caption,  msg, QMessageBox::Ok ); 
    2672                 } 
     2726                        msg = tr("No card present"); 
     2727 
     2728                QMessageBox::information( this, caption,  msg, QMessageBox::Ok ); 
    26732729        } 
    26742730        catch (PTEID_Exception &e) 
    26752731        { 
    2676                 QString msg(tr("General exception")); 
    2677                 ShowPTEIDError( e.GetError(), msg ); 
    2678         } 
    2679         catch (...) 
    2680         { 
    2681                 QString msg(tr("Unknown exception")); 
    2682                 ShowPTEIDError( 0, msg ); 
    2683         } 
    2684         return; 
    2685 } 
    2686  
    2687 //***************************************************** 
    2688 // PIN change button clicked 
    2689 //***************************************************** 
    2690 void MainWnd::on_actionPINChange_triggered() 
    2691 { 
    2692         if (!m_CI_Data.isDataLoaded()) 
    2693         { 
    2694                 return; 
    2695         } 
    2696         try 
    2697         { 
    2698                 PTEID_ReaderContext &ReaderContext = ReaderSet.getReaderByName(m_CurrReaderName.toLatin1().data()); 
    2699                 QString                 caption(tr("Identity Card: PIN change")); 
    2700  
    2701                 if (ReaderContext.isCardPresent()) 
    2702                 { 
    2703                         QString PinNameRaw = m_ui.txtPIN_Name->text(); 
    2704                         QString PinName = PinNameRaw.toUtf8().constData(); 
    2705                         if (PinName.length()==0) 
    2706                         { 
    2707                                 //-------------------------- 
    2708                                 // no pin selected in tree 
    2709                                 //-------------------------- 
    2710                                 return; 
    2711                         } 
    2712  
    2713                         PTEID_EIDCard&  Card    = ReaderContext.getEIDCard(); 
    2714                         PTEID_Pins&             Pins    = Card.getPins(); 
    2715  
    2716                         for (unsigned long PinIdx=0; PinIdx<Pins.count(); PinIdx++) 
    2717                         { 
    2718                                 PTEID_Pin&      Pin                     = Pins.getPinByNumber(PinIdx); 
    2719                                 QString         CurrPinName     = Pin.getLabel(); 
    2720  
    2721                                 if (CurrPinName==PinName) 
    2722                                 { 
    2723                                         unsigned long   triesLeft = -1; 
    2724                                         bool                    bResult   = Pin.changePin("","",triesLeft, PinName.toStdString().c_str()); 
    2725                                         QString                 msg(tr("PIN change ")); 
    2726  
    2727                                         msg += bResult?tr("passed"):tr("failed"); 
    2728                                         if (!bResult) 
    2729                                         {  
    2730                                                 //-------------------------- 
    2731                                                 // if it remains to -1, then CANCEL was pressed 
    2732                                                 // so don't give a message 
    2733                                                 //-------------------------- 
    2734                                                 if ((unsigned long)-1 != triesLeft) 
    2735                                                 { 
    2736                                                         QString nrTriesLeft;nrTriesLeft.setNum(triesLeft); 
    2737                                                         msg += tr("\n( Number of tries left: ") + nrTriesLeft + " )"; 
    2738                                                         m_ui.txtPIN_Status->setText(msg); 
    2739                                                         m_ui.txtPIN_Status->setAccessibleName(msg); 
    2740                                                 } 
    2741                                                 else 
    2742                                                 { 
    2743                                                         break; 
    2744                                                 } 
    2745                                         } 
    2746  
    2747                                         QMessageBox::information( this, caption,  msg, QMessageBox::Ok ); 
    2748                                         break; 
    2749                                 } 
    2750                         } 
    2751                 } 
    2752                 else 
    2753                 { 
    2754                         QString msg(tr("No card present")); 
    2755                         QMessageBox::information( this, caption,  msg, QMessageBox::Ok ); 
    2756                 } 
    2757         } 
    2758         catch (PTEID_Exception &e) 
    2759         { 
    2760                 QString msg(tr("General exception")); 
     2732                QString msg; 
     2733 
     2734                switch(e.GetError()){ 
     2735                case EIDMW_ERR_PIN_CANCEL: 
     2736                        // show nothing user pressed cancel. 
     2737                        return; 
     2738                case EIDMW_ERR_TIMEOUT: 
     2739                        msg = tr("Time for entering PIN expired (30 seconds)"); 
     2740                        break; 
     2741                default: 
     2742                        msg = tr("General exception"); 
     2743                } 
    27612744                ShowPTEIDError( e.GetError(), msg ); 
    27622745        } 
     
    28022785        setLanguage(); 
    28032786        m_ui.stackedWidget->setCurrentIndex(1); 
     2787        m_ui.btnSelectTab_Identity->setFocus(); 
    28042788} 
    28052789 
     
    28392823} 
    28402824 
    2841 //***************************************************** 
    2842 // fill up the certificate tree 
    2843 //***************************************************** 
    2844 void MainWnd::fillCertTree(PTEID_Certificate *cert, short level, QTreeCertItem* item) 
    2845 { 
    2846 #define COLUMN_CERT_NAME 0 
    2847  
    2848         //------------------------------------------------------ 
    2849         // in case of root level, then create an item in the tree widget 
    2850         // else create an item connected to the previous item 
    2851         //------------------------------------------------------ 
    2852         if (0==level) 
    2853         { 
    2854                 item = new QTreeCertItem( m_ui.treeCert, 0 ); 
    2855         } 
    2856         else 
    2857         { 
    2858                 item = new QTreeCertItem( item, 0 ); 
    2859         } 
    2860  
    2861         //------------------------------------------------------ 
    2862         // set the text for the the created item 
    2863         //------------------------------------------------------ 
    2864         if (cert) 
    2865         { 
    2866                 const char* label = cert->getLabel(); 
    2867                 QString strLabel = QString::fromUtf8(label); 
    2868                 item->setText(COLUMN_CERT_NAME, strLabel); 
    2869  
    2870                 item->setIssuer(QString::fromUtf8(cert->getIssuerName(),-1)); 
    2871                 item->setOwner(QString::fromUtf8(cert->getOwnerName(),-1)); 
    2872                 item->setValidityBegin(cert->getValidityBegin()); 
    2873                 item->setValidityEnd(cert->getValidityEnd()); 
    2874                 QString strKeyLen; 
    2875                 strKeyLen=strKeyLen.setNum(cert->getKeyLength()); 
    2876                 item->setKeyLen(strKeyLen); 
    2877         } 
    2878  
    2879         PTEID_Certificate*      child   = NULL; 
    2880  
    2881         for (unsigned long ulIndex = 0; ulIndex<cert->countChildren();ulIndex++) 
    2882         { 
    2883                 //------------------------------------------------------ 
    2884                 // get the child certificate if it exists 
    2885                 //------------------------------------------------------ 
    2886                 child=&cert->getChildren(ulIndex); 
    2887                 fillCertTree(child, level+1, item); 
     2825QTreeCertItem* MainWnd::buildTree(PTEID_Certificate &cert, bool &bEx){ 
     2826        if (cert.isRoot()) 
     2827                return new QTreeCertItem(m_ui.treeCert,0,cert); 
     2828        else { 
     2829                QList<QTreeWidgetItem *> listItem = m_ui.treeCert->findItems(QString::fromUtf8(cert.getOwnerName()), Qt::MatchContains | Qt::MatchRecursive); 
     2830                if (listItem.isEmpty() || dynamic_cast<QTreeCertItem *>(listItem.first())->getLabel().compare(QString::fromUtf8(cert.getLabel()))!=0){ 
     2831                        try { 
     2832                                return new QTreeCertItem(buildTree(cert.getIssuer(),bEx),0,cert); 
     2833                        } catch (PTEID_ExCertNoIssuer &ex){ 
     2834                                bEx = true; 
     2835                                return new QTreeCertItem(m_ui.treeCert,0,cert); 
     2836                        } 
     2837                } 
     2838                else 
     2839                        return dynamic_cast<QTreeCertItem *>(listItem.first()); 
    28882840        } 
    28892841} 
     
    28912843void MainWnd::fillCertificateList( void ) 
    28922844{ 
     2845        bool noIssuer = false; 
     2846 
    28932847        PTEID_Certificates* certificates = m_CI_Data.m_CertifInfo.getCertificates(); 
    28942848 
    28952849        if (!certificates) 
    2896         { 
    28972850                return; 
    2898         } 
    2899  
    2900         try 
    2901         { 
    2902                 short Level=1; 
    2903                 std::string msgtitle = "O Certificado não foi encontrado"; 
    2904                 /* Root Certificate if the card owns it 
    2905                 PTEID_Certificate& certificate = certificates->getCert(4); 
    2906                 fillCertTree(&certificate,Level,NULL); 
    2907                 */ 
    2908  
    2909                 QTreeCertItem* item1 = new QTreeCertItem( m_ui.treeCert, 0 ); 
    2910                 item1 = new QTreeCertItem( m_ui.treeCert, 0 ); 
    2911  
    2912                 QString strLabel1 = QString::fromUtf8(certificates->getExternalCertSubject(1)); 
    2913                 if (strLabel1 == NULL) 
    2914                 { 
    2915                         std::string certerrmsggte = "<p>O Certificado GTE Global Root não foi encontrado." \ 
    2916                                                                              " A sua cadeia de certificação está incorrecta." \ 
    2917                                                                              "<p>Verifique o caminho do certificado."; 
    2918                         QMessageBox msgBoxgte(QMessageBox::Warning, QString::fromUtf8(msgtitle.c_str()), QString::fromUtf8(certerrmsggte.c_str()), 0, this); 
    2919                         msgBoxgte.exec(); 
    2920                 } 
    2921                 item1->setText(COLUMN_CERT_NAME, strLabel1); 
    2922                 item1->setIssuer(QString::fromUtf8(certificates->getExternalCertIssuer(1))); 
    2923                 item1->setOwner(QString::fromUtf8(certificates->getExternalCertSubject(1),-1)); 
    2924                 item1->setValidityBegin(QString::fromUtf8(certificates->getExternalCertNotBefore(1))); 
    2925                 item1->setValidityEnd(QString::fromUtf8(certificates->getExternalCertNotAfter(1))); 
    2926                 QString strKeyLen1; 
    2927                 strKeyLen1=strKeyLen1.setNum(certificates->getExternalCertKeylenght(1)); 
    2928                 item1->setKeyLen(strKeyLen1); 
    2929  
    2930                 QTreeCertItem* item2 = new QTreeCertItem( m_ui.treeCert, 0 ); 
    2931                 item2 = new QTreeCertItem( item1, 0 ); 
    2932  
    2933                 QString strLabel2 = QString::fromUtf8(certificates->getExternalCertSubject(2)); 
    2934                 if (strLabel2 == NULL) 
    2935                 { 
    2936                         std::string certerrmsgecraiz = "<p>O Certificado EC Raiz do Estado não foi encontrado." \ 
    2937                                                                                " A sua cadeia de certificação está incorrecta." \ 
    2938                                                                                "<p>Verifique o caminho do certificado."; 
    2939                         QMessageBox msgBoxec(QMessageBox::Warning, QString::fromUtf8(msgtitle.c_str()), QString::fromUtf8(certerrmsgecraiz.c_str()), 0, this); 
    2940                         msgBoxec.exec(); 
    2941                 } 
    2942                 item2->setText(COLUMN_CERT_NAME, strLabel2); 
    2943                 item2->setIssuer(QString::fromUtf8(certificates->getExternalCertIssuer(2))); 
    2944                 item2->setOwner(QString::fromUtf8(certificates->getExternalCertSubject(2),-1)); 
    2945                 item2->setValidityBegin(QString::fromUtf8(certificates->getExternalCertNotBefore(2))); 
    2946                 item2->setValidityEnd(QString::fromUtf8(certificates->getExternalCertNotAfter(2))); 
    2947                 QString strKeyLen2; 
    2948                 strKeyLen2=strKeyLen2.setNum(certificates->getExternalCertKeylenght(2)); 
    2949                 item2->setKeyLen(strKeyLen2); 
    2950  
    2951                 QTreeCertItem* item3 = new QTreeCertItem( m_ui.treeCert, 0 ); 
    2952                 item3 = new QTreeCertItem( item2, 0 ); 
    2953  
    2954                 QString strLabel3 = QString::fromUtf8(certificates->getExternalCertSubject(3)); 
    2955                 if (strLabel3 == NULL) 
    2956                 { 
    2957                         std::string certerrmsgcc = "<p>O Certificado Cartão de Cidadão 001 não foi encontrado." \ 
    2958                                                                            " A sua cadeia de certificação está incorrecta." \ 
    2959                                                                            "<p>Verifique o caminho do certificado."; 
    2960                         QMessageBox msgBoxcc(QMessageBox::Warning, QString::fromUtf8(msgtitle.c_str()), QString::fromUtf8(certerrmsgcc.c_str()), 0, this); 
    2961                         msgBoxcc.exec(); 
    2962                 } 
    2963                 item3->setText(COLUMN_CERT_NAME, strLabel3); 
    2964                 item3->setIssuer(QString::fromUtf8(certificates->getExternalCertIssuer(3))); 
    2965                 item3->setOwner(QString::fromUtf8(certificates->getExternalCertSubject(3),-1)); 
    2966                 item3->setValidityBegin(QString::fromUtf8(certificates->getExternalCertNotBefore(3))); 
    2967                 item3->setValidityEnd(QString::fromUtf8(certificates->getExternalCertNotAfter(3))); 
    2968                 QString strKeyLen3; 
    2969                 strKeyLen3=strKeyLen3.setNum(certificates->getExternalCertKeylenght(3)); 
    2970                 item3->setKeyLen(strKeyLen3); 
    2971  
    2972                 // Sign Certificate 
    2973                 PTEID_Certificate& certificatesign = certificates->getCert(2); 
    2974                 fillCertTree(&certificatesign, Level,item3); 
    2975  
    2976                 // Auth Certificate 
    2977                 PTEID_Certificate& certificateauth = certificates->getCert(3); 
    2978                 fillCertTree(&certificateauth, Level,item3); 
    2979  
    2980                 m_ui.treeCert->expandAll(); 
    2981                 m_ui.treeCert->setColumnCount(1); 
    2982                 m_ui.treeCert->takeTopLevelItem(0); 
    2983                 m_ui.treeCert->takeTopLevelItem(1); 
    2984                 m_ui.treeCert->takeTopLevelItem(1); 
    2985                 m_ui.treeCert->sortItems(0,Qt::DescendingOrder); 
    2986         } 
    2987         catch(PTEID_ExCertNoRoot &e) 
    2988         { 
    2989                 long err = e.GetError(); 
    2990                 err = err; 
    2991                 return; 
     2851 
     2852        buildTree(certificates->getCert(PTEID_Certificate::CITIZEN_AUTH),noIssuer); 
     2853        buildTree(certificates->getCert(PTEID_Certificate::CITIZEN_SIGN),noIssuer); 
     2854 
     2855        m_ui.treeCert->expandAll(); 
     2856        m_ui.treeCert->setColumnCount(1); 
     2857        m_ui.treeCert->sortItems(0,Qt::DescendingOrder); 
     2858        if (m_ui.treeCert->topLevelItem(0)) 
     2859                m_ui.treeCert->setCurrentItem (m_ui.treeCert->topLevelItem(0)); 
     2860 
     2861        if (noIssuer){ 
     2862                QString title = tr("Certification path"); 
     2863                QString msg = tr("The certificates could not be validated, the certification path is not complete"); 
     2864                QMessageBox msgBoxcc(QMessageBox::Warning, title, msg, 0, this); 
     2865                msgBoxcc.setModal(true) ; 
     2866                msgBoxcc.exec(); 
    29922867        } 
    29932868} 
     
    30092884                 
    30102885                //Load data from card in a new thread 
    3011                 CardDataLoader loader(m_CI_Data, Card, m_CurrReaderName); 
     2886                CardDataLoader loader(m_CI_Data, Card, m_CurrReaderName, this); 
    30122887                QFuture<void> future = QtConcurrent::run(&loader, &CardDataLoader::Load); 
    30132888                this->FutureWatcher.setFuture(future); 
     
    30202895                imgPicturescaled = imgPicture.scaled(150, 190); 
    30212896                m_imgPicture = QPixmap::fromImage(imgPicturescaled); 
    3022                 clearTabCertificates(); 
    3023                 clearTabAddress(); 
    3024                 clearTabPins(); 
    3025                 fillPinList( Card ); 
     2897 
     2898                fillPinList(); 
    30262899        } 
    30272900} 
     
    30362909        if(!m_CI_Data.isDataLoaded()) 
    30372910        { 
    3038                 clearTabCertificates(); 
    3039                 clearTabAddress(); 
    3040  
    3041                 clearTabPins(); 
    3042                 fillPinList( Card ); 
     2911                //clearTabCertificates(); 
     2912                //clearTabAddress(); 
     2913 
     2914                //clearTabPins(); 
     2915                //fillPinList( Card ); 
    30432916        } 
    30442917} 
     
    30762949#define COLUMN_PIN_NAME   0 
    30772950 
    3078 //***************************************************** 
    3079 // fill the PIN list on the window 
    3080 //***************************************************** 
    3081 void MainWnd::fillPinList(PTEID_EIDCard& Card) 
    3082 { 
     2951void MainWnd::fillPinList() 
     2952{ 
     2953        QTreeWidgetItem* pinTreeItem; 
     2954 
     2955        clearTabPins(); 
     2956 
     2957        pinTreeItem = new QTreeWidgetItem( TYPE_PINTREE_ITEM ); 
     2958        pinTreeItem->setText(COLUMN_PIN_NAME, m_pinsInfo[PTEID_Pin::AUTH_PIN]->pin_name); 
     2959        m_ui.treePIN->addTopLevelItem ( pinTreeItem ); 
     2960        pinTreeItem->setData(0, Qt::UserRole, QVariant((uint)PTEID_Pin::AUTH_PIN)); 
     2961 
     2962        pinTreeItem = new QTreeWidgetItem( TYPE_PINTREE_ITEM ); 
     2963        pinTreeItem->setText(COLUMN_PIN_NAME, m_pinsInfo[PTEID_Pin::SIGN_PIN]->pin_name); 
     2964        m_ui.treePIN->addTopLevelItem ( pinTreeItem ); 
     2965        pinTreeItem->setData(0, Qt::UserRole, QVariant((uint)PTEID_Pin::SIGN_PIN)); 
     2966 
     2967        pinTreeItem = new QTreeWidgetItem( TYPE_PINTREE_ITEM ); 
     2968        pinTreeItem->setText(COLUMN_PIN_NAME, m_pinsInfo[PTEID_Pin::ADDR_PIN]->pin_name); 
     2969        m_ui.treePIN->addTopLevelItem ( pinTreeItem ); 
     2970        pinTreeItem->setData(0, Qt::UserRole, QVariant((uint)PTEID_Pin::ADDR_PIN)); 
     2971 
     2972        m_ui.treePIN->expandAll(); 
     2973 
     2974        m_ui.treePIN->topLevelItem(0)->setSelected(true); 
     2975        m_ui.treePIN->setCurrentItem (m_ui.treePIN->topLevelItem(0)); 
     2976} 
     2977 
     2978void MainWnd::loadPinData(PTEID_EIDCard& Card){ 
     2979 
    30832980        PTEID_Pins& Pins = Card.getPins(); 
    30842981 
    3085         for ( unsigned long PinNr = 0; PinNr < Pins.count(); PinNr++ ) 
    3086         { 
    3087                 PTEID_Pin& Pin = Pins.getPinByNumber(PinNr); 
    3088                 QString         DispPinName     = QString::fromLocal8Bit(Pin.getLabel()); 
    3089  
    3090                 QTreeWidgetItem* PinTreeItem = new QTreeWidgetItem( TYPE_PINTREE_ITEM ); 
    3091  
    3092                 std::string pinname = "PIN"; 
    3093  
    3094                 if (!DispPinName.toStdString().find(pinname)) 
    3095                 { 
    3096                         PinTreeItem->setText(COLUMN_PIN_NAME, trUtf8(Pin.getLabel())); 
    3097                         m_ui.treePIN->addTopLevelItem ( PinTreeItem ); 
    3098                 } 
    3099  
    3100                 if (0==PinNr) 
    3101                 { 
    3102                         PinTreeItem->setSelected(true); 
    3103                 } 
    3104         } 
    3105         m_ui.treePIN->expandAll(); 
    3106  
    3107         QList<QTreeWidgetItem*> treeList = m_ui.treePIN->findItems("PIN ",Qt::MatchContains); 
    3108         if (treeList.size() > 0) 
    3109         { 
    3110                 treeList[0]->setSelected(true); 
    3111                 on_treePIN_itemClicked(treeList[0], 0); 
    3112         } 
    3113 } 
     2982        PTEID_Pin& pinAuth = Pins.getPinByPinRef(PTEID_Pin::AUTH_PIN); 
     2983        m_pinsInfo[PTEID_Pin::AUTH_PIN] = new PinInfo(pinAuth.getId(), pinAuth.getLabel(), pinAuth.getTriesLeft()); 
     2984 
     2985        PTEID_Pin& pinSign = Pins.getPinByPinRef(PTEID_Pin::SIGN_PIN); 
     2986        m_pinsInfo[PTEID_Pin::SIGN_PIN] = new PinInfo(pinSign.getId(), pinSign.getLabel(), pinSign.getTriesLeft()); 
     2987 
     2988        PTEID_Pin& pinAddr = Pins.getPinByPinRef(PTEID_Pin::ADDR_PIN); 
     2989        m_pinsInfo[PTEID_Pin::ADDR_PIN] = new PinInfo(pinAddr.getId(), pinAddr.getLabel(), pinAddr.getTriesLeft()); 
     2990} 
     2991 
    31142992 
    31152993QString MainWnd::getFinalLinkTarget(QString baseName) 
     
    33973275        m_CurrReaderName = ""; 
    33983276 
    3399         setStatus( SPECIALSTATUS_NA ); 
    3400  
    34013277        clearTabCertificates(); 
    34023278        clearTabPins(); 
     
    34053281        enablePrintMenu(); 
    34063282} 
    3407  
    3408 //***************************************************** 
    3409 // put the card status info on the window 
    3410 //***************************************************** 
    3411 void MainWnd::setStatus( unsigned int Status ) 
    3412 { 
    3413         QString tmp; 
    3414         switch( Status ) 
    3415         { 
    3416         case SPECIALSTATUS_NA: 
    3417                 tmp = ""; 
    3418                 break; 
    3419         case SPECIALSTATUS_YELLOWCANE: 
    3420                 tmp = "Yellow cane"; 
    3421                 break; 
    3422  
    3423         case SPECIALSTATUS_WHITECANE: 
    3424                 tmp = "White cane"; 
    3425                 break; 
    3426  
    3427         case SPECIALSTATUS_EXTMINORITY: 
    3428                 tmp = "Extended minority"; 
    3429                 break; 
    3430  
    3431         default: 
    3432                 tmp = "Unkown"; 
    3433                 break; 
    3434         } 
    3435 } 
    3436  
    3437  
    3438  
    3439  
    3440 void MainWnd::setWidgetsPointSize(QList<QWidget *> &allWidgets) 
    3441 { 
    3442         //zoomAllWidgets(allWidgets); 
    3443 } 
    3444  
    34453283 
    34463284//***************************************************** 
     
    35353373} 
    35363374 
     3375void MainWnd::clearAddressData(void){ 
     3376        m_ui.txtAddress_Municipality->setText(QString()); 
     3377        m_ui.txtAddress_Municipality->setAccessibleName(QString()); 
     3378        m_ui.txtAddress_District->setText(QString()); 
     3379        m_ui.txtAddress_District->setAccessibleName(QString()); 
     3380        m_ui.txtAddress_CivilParish->setText(QString()); 
     3381        m_ui.txtAddress_CivilParish->setAccessibleName(QString()); 
     3382        m_ui.txtAddress_StreetType1->setText(QString()); 
     3383        m_ui.txtAddress_StreetType1->setAccessibleName(QString()); 
     3384        m_ui.txtAddress_StreetType2->setText(QString()); 
     3385        m_ui.txtAddress_StreetType2->setAccessibleName(QString()); 
     3386        m_ui.txtAddress_StreetName->setText(QString()); 
     3387        m_ui.txtAddress_StreetName->setAccessibleName(QString()); 
     3388        m_ui.txtAddress_BuildingType1->setText(QString()); 
     3389        m_ui.txtAddress_BuildingType1->setAccessibleName(QString()); 
     3390        m_ui.txtAddress_BuildingType2->setText(QString()); 
     3391        m_ui.txtAddress_BuildingType2->setAccessibleName(QString()); 
     3392        m_ui.txtAddress_DoorNo->setText(QString()); 
     3393        m_ui.txtAddress_DoorNo->setAccessibleName(QString()); 
     3394        m_ui.txtAddress_Floor->setText(QString()); 
     3395        m_ui.txtAddress_Floor->setAccessibleName(QString()); 
     3396        m_ui.txtAddress_Side->setText(QString()); 
     3397        m_ui.txtAddress_Side->setAccessibleName(QString()); 
     3398        m_ui.txtAddress_Locality->setText(QString()); 
     3399        m_ui.txtAddress_Locality->setAccessibleName(QString()); 
     3400        m_ui.txtAddress_Zip4->setText(QString()); 
     3401        m_ui.txtAddress_Zip4->setAccessibleName(QString()); 
     3402        m_ui.txtAddress_Zip3->setText(QString()); 
     3403        m_ui.txtAddress_Zip3->setAccessibleName(QString()); 
     3404        m_ui.txtAddress_Place->setText(QString()); 
     3405        m_ui.txtAddress_Place->setAccessibleName(QString()); 
     3406        m_ui.txtAddress_PostalLocality->setText(QString()); 
     3407        m_ui.txtAddress_PostalLocality->setAccessibleName(QString()); 
     3408 
     3409} 
     3410 
    35373411//***************************************************** 
    35383412// refresh the tab with the PTeid Address 
     
    35423416    if (!m_CI_Data.isDataLoaded()) 
    35433417        return; 
     3418 
    35443419 
    35453420        if (pinactivate == 1) 
     
    36043479        m_ui.txtPersoDataCount->setText(TotalBytes); 
    36053480 
    3606     if (TxtPersoDataString.count()>1000) 
    3607     { 
    3608                 TxtPersoDataString = m_ui.txtPersoData->toPlainText(); 
    3609                 TxtPersoDataString.truncate(TxtPersoDataString.size()-1); 
    3610                 m_ui.txtPersoData->setPlainText(TxtPersoDataString); 
    3611         } 
     3481        if (TxtPersoDataString.count()>1000) 
     3482                m_ui.txtPersoData->textCursor().deletePreviousChar(); 
    36123483} 
    36133484 
     
    38343705                        case PTEID_CARDTYPE_IAS101: 
    38353706                { 
    3836                     PTEID_EIDCard&      Card    = ReaderContext.getEIDCard(); 
    3837                     PTEID_Pins&         Pins    = Card.getPins(); 
    3838                     PTEID_Pin&  Auth_Pin = Pins.getPinByNumber(0); 
    3839                     QString     CurrPinName     = Auth_Pin.getLabel(); 
    3840  
    3841                     QString PINStatus; 
    3842                     PINStatus.sprintf("Resta(m) %ld tentativa(s)", Auth_Pin.getTriesLeft()); 
    3843  
    3844                     list_of_pins[0].pin_status = PINStatus; 
    3845  
    3846                     //------------------------------------ 
    3847                     // fill in the fields 
    3848                     //------------------------------------ 
    3849                     m_ui.txtPIN_Name->setText(QString::fromUtf8("PIN da Autentica\xc3\xa7\xc3\xa3o")); 
    3850                     m_ui.txtPIN_Name->setAccessibleName(QString::fromUtf8("PIN da Autentica\xc3\xa7\xc3\xa3o")); 
    3851                     m_ui.txtPIN_ID->setText(QString::number(1)); 
    3852                     m_ui.txtPIN_ID->setAccessibleName(QString::number(1)); 
    3853                     m_ui.txtPIN_Status->setText(PINStatus); 
    3854                     m_ui.txtPIN_Status->setAccessibleName(PINStatus); 
    3855  
     3707                        QTreeWidgetItem *item = m_ui.treePIN->currentItem(); 
     3708 
     3709                        unsigned int pinRef = item->data(0,Qt::UserRole).value<uint>(); 
     3710                        unsigned long triesLeft = m_pinsInfo[pinRef]->triesLeft; 
     3711 
     3712                        QString status; 
     3713                        if (1 == m_pinsInfo.find(pinRef)->second->triesLeft) 
     3714                                status = tr("%1 try remaining").arg(m_pinsInfo.find(pinRef)->second->triesLeft); 
     3715                        else 
     3716                                status = tr("%1 tries remaining").arg(m_pinsInfo.find(pinRef)->second->triesLeft); 
     3717                        m_ui.txtPIN_Name->setText(m_pinsInfo.find(pinRef)->second->pin_name); 
     3718                        m_ui.txtPIN_Name->setAccessibleName(m_pinsInfo.find(pinRef)->second->pin_name); 
     3719                        m_ui.txtPIN_ID->setText(m_pinsInfo.find(pinRef)->second->pin_id); 
     3720                        m_ui.txtPIN_ID->setAccessibleName(m_pinsInfo.find(pinRef)->second->pin_id); 
     3721                        m_ui.txtPIN_Status->setText(status); 
     3722                        m_ui.txtPIN_Status->setAccessibleName(status); 
    38563723                } 
    38573724                        default: 
     
    41624029                                        setEnabledCertifButtons(false); 
    41634030                                        enableFileSave(false); 
     4031 
     4032                                        m_imgPicture = NULL; 
     4033                                        m_pinsInfo.clear(); 
     4034                                        m_CI_Data.Reset(); 
     4035                                        refreshTabIdentity(); 
     4036                                        refreshTabIdentityExtra(); 
     4037                                        refreshTabPersoData(); 
     4038                                        refreshTabCardPin(); 
     4039                                        refreshTabCertificates(); 
     4040                                        clearAddressData(); 
     4041                                        m_ui.btnSelectTab_Identity->setFocus(); 
     4042 
    41644043                                } 
    41654044                                //---------------------------------------------------------- 
     
    45214400} 
    45224401#endif 
     4402 
     4403void CardDataLoader::Load() 
     4404{ 
     4405        this->information.LoadData(card, readerName); 
     4406        if (this->mwnd) 
     4407                this->mwnd->loadPinData(this->card); 
     4408} 
     4409 
     4410void CardDataLoader::LoadPersoData() 
     4411{ 
     4412        this->information.LoadDataPersoData(card, readerName); 
     4413} 
     4414 
     4415void CardDataLoader::LoadCertificateData() 
     4416{ 
     4417        this->information.LoadDataCertificates(card, readerName); 
     4418} 
     4419 
     4420 
     4421 
     4422 
  • middleware-offline/trunk/_src/eidmw/eidgui/mainwnd.h

    r109 r145  
    2222#define MAINWND_H 
    2323 
     24#include <map> 
    2425#include <QtGui> 
    2526#include <QFutureWatcher> 
     
    5253public: 
    5354        QString pin_name; 
    54         QString pin_status; 
     55        unsigned long triesLeft; 
    5556        QString pin_id; 
    5657 
    5758        PinInfo() {}; 
    58         PinInfo(int id, const char *pin_name, const char *pin_status=""):  
    59           pin_name(QString::fromUtf8(pin_name)), pin_id(QString::number(id)), pin_status(QString::fromUtf8(pin_status)) 
     59        PinInfo(unsigned long id, const char *pin_name, long tLeft): 
     60          pin_name(QString::fromUtf8(pin_name)), pin_id(QString::number(id)), triesLeft(tLeft) 
    6061          { }; 
    6162}; 
     
    165166{ 
    166167public: 
    167         QTreeCertItem(QTreeWidget *view, int type):QTreeWidgetItem(view,type) {} 
    168         QTreeCertItem(QTreeCertItem *parent, int type):QTreeWidgetItem(parent,type){} 
    169  
    170         void setIssuer(QString Issuer) {m_Issuer=Issuer;} 
     168        QTreeCertItem(int type, PTEID_Certificate &cert):QTreeWidgetItem(QStringList(QString::fromUtf8(cert.getOwnerName())),type) {init(cert);} 
     169        QTreeCertItem(QTreeWidget *view, int type, PTEID_Certificate &cert):QTreeWidgetItem(view,QStringList(QString::fromUtf8(cert.getOwnerName())),type) {init(cert);} 
     170        QTreeCertItem(QTreeCertItem *parent, int type, PTEID_Certificate &cert):QTreeWidgetItem(parent,QStringList(QString::fromUtf8(cert.getOwnerName())),type){init(cert);} 
     171 
     172 
    171173        QString const& getIssuer() {return m_Issuer;} 
    172  
    173         void setOwner(QString Owner) {m_Owner=Owner;} 
    174174        QString const& getOwner() {return m_Owner;} 
    175  
    176         void setValidityBegin(QString ValidityBegin) {m_ValidityBegin=ValidityBegin;} 
    177175        QString const& getValidityBegin() {return m_ValidityBegin;} 
    178  
    179         void setValidityEnd(QString ValidityEnd) {m_ValidityEnd=ValidityEnd;} 
    180176        QString const& getValidityEnd() {return m_ValidityEnd;} 
    181  
    182         void setKeyLen(QString KeyLen) {m_KeyLen=KeyLen;} 
    183177        QString const& getKeyLen() {return m_KeyLen;} 
     178        QString const& getLabel() {return m_Label;} 
     179        PTEID_Certificate *getCert() { return cert;} 
    184180 
    185181private: 
     
    189185        QString m_ValidityEnd; 
    190186        QString m_KeyLen; 
     187        QString m_Label; 
     188        PTEID_Certificate *cert; 
     189 
     190        void init(PTEID_Certificate &cert){ 
     191                this->cert = &cert; 
     192                m_Issuer = QString::fromUtf8(cert.getIssuerName()); 
     193                m_Owner = QString::fromUtf8(cert.getOwnerName()); 
     194                m_ValidityBegin = QString::fromUtf8(cert.getValidityBegin()); 
     195                m_ValidityEnd = QString::fromUtf8(cert.getValidityEnd()); 
     196                m_KeyLen = QString::number(cert.getKeyLength()); 
     197                m_Label = QString::fromUtf8(cert.getLabel()); 
     198        } 
     199}; 
     200 
     201/* Helper Class for Threaded Data Loading */ 
     202class CardDataLoader 
     203{ 
     204private: 
     205        CardInformation& information; 
     206        PTEID_EIDCard &card; 
     207        QString &readerName; 
     208        MainWnd *mwnd; 
     209 
     210 
     211public: 
     212        CardDataLoader(CardInformation& info, PTEID_EIDCard& Card, QString& ReaderName, MainWnd *mw = NULL): 
     213                information(info), card(Card), readerName(ReaderName), mwnd(mw) 
     214        { } 
     215 
     216        void Load(); 
     217        void LoadPersoData(); 
     218        void LoadCertificateData(); 
    191219}; 
    192220 
     
    303331        QFutureWatcher<void> FutureWatcher; 
    304332 
    305         PinInfo list_of_pins[3];  
     333        PinInfo list_of_pins[3]; 
     334        std::map<long unsigned int,PinInfo *> m_pinsInfo; 
    306335 
    307336 
     
    313342        bool loadCardDataPersoData (); 
    314343        void loadCardDataCertificates (); 
    315         void setStatus( unsigned int Status ); 
    316344 
    317345        // Refresh Data 
     
    324352        void refreshTabIdentityExtra( void ); 
    325353        void refreshTabAddress( void ); 
     354        void clearAddressData( void ); 
    326355        void refreshTabPersoData( void ); 
    327356        void refreshTabCertificates( void ); 
     
    381410                } 
    382411        } 
     412        void ChangeAuthPin(PTEID_ReaderContext&, unsigned int); 
    383413        void fillSoftwareInfo( void ); 
    384414        void setLanguageMenu( GenPur::UI_LANGUAGE language ); 
     
    392422        void enablePrintMenu( void ); 
    393423        bool ImportSelectedCertificate( void ); 
    394         unsigned long getCertificateIndex( QString const& label ); 
    395         void fillPinList(PTEID_EIDCard& Card); 
     424        void fillPinList( void ); 
     425        void loadPinData(PTEID_EIDCard& Card); 
    396426        void fillCertificateList( void ); 
    397427        void stopAllEventCallbacks( void ); 
     
    417447        void releaseVirtualReader( void ); 
    418448        void doPicturePopup( PTEID_Card& card ); 
    419         void setWidgetsPointSize(QList<QWidget *> &allWidgets); 
    420449        void setCorrespondingTrayIcon( PopupEvent* callbackEvent ); 
    421450        void clearGuiContent( void ); 
     
    426455        QString getFinalLinkTarget(QString baseName);    
    427456        void cleanupCallbackData(); 
     457        QTreeCertItem* buildTree(PTEID_Certificate &cert, bool &bEx); 
    428458 
    429459        eZOOMSTATUS                             m_Zoom; 
     
    453483        static tCertPerReader                   m_certContexts;                 //!< certificate contexts of each reader 
    454484 
    455 }; 
    456  
    457  
    458 /* Helper Class for Threaded Data Loading */ 
    459 class CardDataLoader 
    460 { 
    461 private: 
    462         CardInformation& information; 
    463         PTEID_EIDCard &card; 
    464         QString &readerName; 
    465  
    466          
    467         public: 
    468         CardDataLoader(CardInformation& info, PTEID_EIDCard& Card, QString& ReaderName):  
    469                 information(info), card(Card), readerName(ReaderName) 
    470         { } 
    471  
    472         void Load() 
    473         { 
    474                 this->information.LoadData(card, readerName); 
    475         } 
    476  
    477         void LoadPersoData() 
    478         { 
    479                 this->information.LoadDataPersoData(card, readerName); 
    480         } 
    481  
    482         void LoadCertificateData() 
    483         { 
    484                 this->information.LoadDataCertificates(card, readerName); 
    485         } 
    486 }; 
    487  
     485friend void CardDataLoader::Load(); 
     486}; 
    488487 
    489488#endif 
  • middleware-offline/trunk/_src/eidmw/eidgui/mainwnd.ui

    r133 r145  
    10771077         <bool>false</bool> 
    10781078        </property> 
     1079        <property name="headerHidden"> 
     1080         <bool>false</bool> 
     1081        </property> 
    10791082        <attribute name="headerVisible"> 
    10801083         <bool>false</bool> 
     
    10921095        <property name="geometry"> 
    10931096         <rect> 
    1094           <x>408</x> 
    1095           <y>47</y> 
     1097          <x>410</x> 
     1098          <y>50</y> 
    10961099          <width>380</width> 
    10971100          <height>20</height> 
     
    11081111        <property name="geometry"> 
    11091112         <rect> 
    1110           <x>408</x> 
    1111           <y>95</y> 
     1113          <x>410</x> 
     1114          <y>120</y> 
    11121115          <width>380</width> 
    11131116          <height>20</height> 
     
    11251128         <rect> 
    11261129          <x>410</x> 
    1127           <y>190</y> 
     1130          <y>245</y> 
    11281131          <width>175</width> 
    11291132          <height>20</height> 
     
    11411144         <rect> 
    11421145          <x>410</x> 
    1143           <y>143</y> 
     1146          <y>180</y> 
    11441147          <width>175</width> 
    11451148          <height>20</height> 
     
    11571160         <rect> 
    11581161          <x>610</x> 
    1159           <y>143</y> 
     1162          <y>180</y> 
    11601163          <width>175</width> 
    11611164          <height>20</height> 
     
    11671170        <property name="readOnly"> 
    11681171         <bool>true</bool> 
    1169         </property> 
    1170        </widget> 
    1171        <widget class="QLabel" name="lbl_owner_entity"> 
    1172         <property name="geometry"> 
    1173          <rect> 
    1174           <x>408</x> 
    1175           <y>25</y> 
    1176           <width>341</width> 
    1177           <height>17</height> 
    1178          </rect> 
    1179         </property> 
    1180         <property name="styleSheet"> 
    1181          <string notr="true">background-image: url(:/images/Images/alpha.png); 
    1182 color: rgb(108, 108, 108); 
    1183 font: 10pt &quot;Arial&quot;;</string> 
    1184         </property> 
    1185         <property name="text"> 
    1186          <string>Cidadão / Entidade</string> 
    1187         </property> 
    1188        </widget> 
    1189        <widget class="QLabel" name="lbl_issue_entity"> 
    1190         <property name="geometry"> 
    1191          <rect> 
    1192           <x>408</x> 
    1193           <y>74</y> 
    1194           <width>121</width> 
    1195           <height>17</height> 
    1196          </rect> 
    1197         </property> 
    1198         <property name="styleSheet"> 
    1199          <string notr="true">background-image: url(:/images/Images/alpha.png); 
    1200 color: rgb(108, 108, 108); 
    1201 font: 10pt &quot;Arial&quot;;</string> 
    1202         </property> 
    1203         <property name="text"> 
    1204          <string>Entidade Emissora</string> 
    1205         </property> 
    1206        </widget> 
    1207        <widget class="QLabel" name="lbl_valid_form"> 
    1208         <property name="geometry"> 
    1209          <rect> 
    1210           <x>408</x> 
    1211           <y>123</y> 
    1212           <width>121</width> 
    1213           <height>17</height> 
    1214          </rect> 
    1215         </property> 
    1216         <property name="styleSheet"> 
    1217          <string notr="true">background-image: url(:/images/Images/alpha.png); 
    1218 color: rgb(108, 108, 108); 
    1219 font: 10pt &quot;Arial&quot;;</string> 
    1220         </property> 
    1221         <property name="text"> 
    1222          <string>Válido desde</string> 
    1223         </property> 
    1224        </widget> 
    1225        <widget class="QLabel" name="lbl_valid_until"> 
    1226         <property name="geometry"> 
    1227          <rect> 
    1228           <x>609</x> 
    1229           <y>123</y> 
    1230           <width>121</width> 
    1231           <height>17</height> 
    1232          </rect> 
    1233         </property> 
    1234         <property name="styleSheet"> 
    1235          <string notr="true">background-image: url(:/images/Images/alpha.png); 
    1236 color: rgb(108, 108, 108); 
    1237 font: 10pt &quot;Arial&quot;;</string> 
    1238         </property> 
    1239         <property name="text"> 
    1240          <string>até</string> 
    1241         </property> 
    1242        </widget> 
    1243        <widget class="QLabel" name="lbl_keysize"> 
    1244         <property name="geometry"> 
    1245          <rect> 
    1246           <x>408</x> 
    1247           <y>172</y> 
    1248           <width>121</width> 
    1249           <height>17</height> 
    1250          </rect> 
    1251         </property> 
    1252         <property name="styleSheet"> 
    1253          <string notr="true">background-image: url(:/images/Images/alpha.png); 
    1254 color: rgb(108, 108, 108); 
    1255 font: 10pt &quot;Arial&quot;;</string> 
    1256         </property> 
    1257         <property name="text"> 
    1258          <string>Tamanho da Chave</string> 
    12591172        </property> 
    12601173       </widget> 
     
    13001213         <rect> 
    13011214          <x>410</x> 
    1302           <y>50</y> 
     1215          <y>60</y> 
    13031216          <width>175</width> 
    13041217          <height>20</height> 
     
    13161229         <rect> 
    13171230          <x>610</x> 
    1318           <y>50</y> 
     1231          <y>60</y> 
    13191232          <width>175</width> 
    13201233          <height>20</height> 
     
    13321245         <rect> 
    13331246          <x>410</x> 
    1334           <y>98</y> 
     1247          <y>130</y> 
    13351248          <width>370</width> 
    13361249          <height>20</height> 
     
    13681281         <rect> 
    13691282          <x>400</x> 
    1370           <y>130</y> 
     1283          <y>180</y> 
    13711284          <width>131</width> 
    13721285          <height>31</height> 
     
    13981311         <rect> 
    13991312          <x>540</x> 
    1400           <y>130</y> 
     1313          <y>180</y> 
    14011314          <width>121</width> 
    14021315          <height>27</height> 
     
    14211334        </property> 
    14221335       </widget> 
    1423        <widget class="QLabel" name="lbl_PIN_type"> 
    1424         <property name="geometry"> 
    1425          <rect> 
    1426           <x>410</x> 
    1427           <y>25</y> 
    1428           <width>121</width> 
    1429           <height>17</height> 
    1430          </rect> 
    1431         </property> 
    1432         <property name="styleSheet"> 
    1433          <string notr="true">background-image: url(:/images/Images/alpha.png); 
    1434 color: rgb(108, 108, 108); 
    1435 font: 10pt &quot;Arial&quot;;</string> 
    1436         </property> 
    1437         <property name="text"> 
    1438          <string>Tipo de Código PIN</string> 
    1439         </property> 
    1440        </widget> 
    1441        <widget class="QLabel" name="lbl_PIN_id"> 
    1442         <property name="geometry"> 
    1443          <rect> 
    1444           <x>610</x> 
    1445           <y>25</y> 
    1446           <width>181</width> 
    1447           <height>17</height> 
    1448          </rect> 
    1449         </property> 
    1450         <property name="styleSheet"> 
    1451          <string notr="true">background-image: url(:/images/Images/alpha.png); 
    1452 color: rgb(108, 108, 108); 
    1453 font: 10pt &quot;Arial&quot;;</string> 
    1454         </property> 
    1455         <property name="text"> 
    1456          <string>Identificação do Código PIN</string> 
    1457         </property> 
    1458        </widget> 
    1459        <widget class="QLabel" name="lbl_PIN_status"> 
    1460         <property name="geometry"> 
    1461          <rect> 
    1462           <x>410</x> 
    1463           <y>75</y> 
    1464           <width>221</width> 
    1465           <height>17</height> 
    1466          </rect> 
    1467         </property> 
    1468         <property name="styleSheet"> 
    1469          <string notr="true">background-image: url(:/images/Images/alpha.png); 
    1470 color: rgb(108, 108, 108); 
    1471 font: 10pt &quot;Arial&quot;;</string> 
    1472         </property> 
    1473         <property name="text"> 
    1474          <string>Estado do Código PIN</string> 
    1475         </property> 
    1476        </widget> 
    14771336      </widget> 
    14781337      <widget class="QWidget" name="page_Notes"> 
     
    15351394        </property> 
    15361395        <property name="text"> 
    1537          <string>Bytes Disponíveis:</string> 
     1396         <string>Bytes available:</string> 
    15381397        </property> 
    15391398       </widget> 
     
    25172376     <y>0</y> 
    25182377     <width>925</width> 
    2519      <height>23</height> 
     2378     <height>25</height> 
    25202379    </rect> 
    25212380   </property> 
  • middleware-offline/trunk/_src/eidmw/eidlib/eidlib.h

    r124 r145  
    3535#define XML_ROOT_ELEMENT_ATTR_SERVERNAME        "servername" 
    3636#define XML_ROOT_ELEMENT_ATTR_SERVERADDRESS     "serveraddress" 
     37#define XML_ROOT_ELEMENT_ATTR_TOKENID           "tokenid" 
    3738#define XML_PHOTO_ELEMENT                                       "photo" 
    3839#define XML_BASIC_INFO_ELEMENT                          "basicInformation" 
     
    880881             PTEIDSDK_API void SignXadesTIndividual(const char * const* paths, unsigned int n_paths, const char *output_path); /** Store the Xades-T signature in individual zip containers  */ 
    881882 
     883             /* Change the OTP/EMV-CAP PIN through interaction with the appropriate HTTPS server 
     884              * Note: This method SHOULD be always called before any change to the Authentication PIN 
     885              * because the two PINs are the same from the user's perspective  
     886              *  
     887              */ 
     888             PTEIDSDK_API bool ChangeCapPin(const char *new_pin); 
     889 
     890             /* helper method for the compatibility layer */ 
     891             PTEIDSDK_API bool ChangeCapPinCompLayer(const char *old_pin, const char *new_pin,unsigned long &ulRemaining); 
     892 
     893 
    882894 
    883895        /** 
     
    943955    PTEIDSDK_API PTEID_XmlUserRequestedInf