source: terepaima/terepaima-0.4.16/sources/cryptotokenOld.cpp

stretch
Last change on this file was 35bdadc, checked in by pbuitrago@…>, 6 years ago

Se agregaron las librerias necesarias para la gestion de dispositivos criptograficos y se modifico mainwindow.cpp y mainwindow.h para la gestion de los dispositivos criptograficos
  • Property mode set to 100644
File size: 41.9 KB
Line 
1#include "cryptotoken.h"
2
3#include <QSslCertificate>
4
5#include <assert.h>
6#include <iostream>
7#include <stdexcept>
8
9#define BINARY_SHA1_LENGTH 20
10#define BINARY_SHA224_LENGTH 28
11#define BINARY_SHA256_LENGTH 32
12#define BINARY_SHA384_LENGTH 48
13#define BINARY_SHA512_LENGTH 64
14
15
16CryptoToken::CryptoToken()
17{
18}
19
20
21CryptoToken::~CryptoToken()
22{
23}
24
25
26bool CryptoToken::initializeCriptoki()
27{
28    QString error("");
29    CK_RV rv;
30    rv = C_Initialize(NULL_PTR);
31    if (rv != CKR_OK)
32    {
33        if (rv == CKR_DEVICE_ERROR)
34        {
35            error = returnErrorToQString(rv);
36            qDebug("%s", qPrintable(error));
37            return false;
38        }
39        error = returnErrorToQString(rv);
40        qDebug("%s", qPrintable(error));
41        return false;
42    }
43    else
44    {
45        return true;
46    }
47}
48
49void CryptoToken::finalize() {
50    CK_RV rv;
51    rv = C_Finalize(NULL_PTR);
52    QString error("");
53    if (rv != CKR_OK)
54    {
55        qDebug("** Destruyendo ... ~SmartCard");
56        if (rv == CKR_DEVICE_ERROR)
57        {
58            error = returnErrorToQString(rv);
59            qDebug("%s", qPrintable(error));
60        }
61        error = returnErrorToQString(rv);
62        qDebug("%s", qPrintable(error));
63    }
64}
65
66CK_SESSION_HANDLE CryptoToken::openSession(char * Pin, CK_SLOT_ID & slotID, bool requiredlogin)
67{
68    qDebug("openSession()");
69    QString error("");
70
71    CK_RV rv;
72
73    CK_SLOT_ID SlotList[10];
74    CK_ULONG ulCount = sizeof(SlotList)/sizeof(CK_SLOT_ID);
75
76    CK_SESSION_HANDLE hSession;
77
78    /*
79    ** Find the first slot available that has a token present
80    */
81    rv = C_GetSlotList(TRUE,SlotList,&ulCount);
82    //assert(rv==CKR_OK);
83    //assert(ulCount>0);
84    //if ( (rv != CKR_OK) && (ulCount<=0) )
85    if ( (rv != CKR_OK) || (ulCount<=0) )
86    {
87        error = returnErrorToQString(rv);
88        qDebug("%s", qPrintable("Insertar una tarjeta en el lector. " + error));
89        return CK_INVALID_HANDLE;
90
91    }
92    //slotID = new CK_SLOT_ID() ;
93    slotID = SlotList[0];
94
95    /*
96    ** Open a read/write session with this slot's token
97    */
98    //rv = C_OpenSession(slotID,CKF_SERIAL_SESSION|CKF_RW_SESSION,0,0,&hSession);
99    rv = C_OpenSession(slotID,CKF_SERIAL_SESSION|CKF_RW_SESSION,NULL_PTR,(CK_NOTIFY)NULL_PTR,&hSession);
100
101    //assert(rv==CKR_OK);
102    if (rv != CKR_OK)
103    {
104        error = returnErrorToQString(rv);
105        qDebug("%s", qPrintable("C_OpenSession" + error));
106        return CK_INVALID_HANDLE;
107    }
108
109    /*
110    ** Log in the User to session
111    */
112    if ( requiredlogin ) {
113        rv = C_Login(hSession,CKU_USER, (unsigned char *) Pin,strlen(Pin));
114        //assert(rv==CKR_OK);
115        if (rv != CKR_OK)
116        {
117            error = returnErrorToQString(rv);
118            QString plus("");
119            if ((rv == CKR_PIN_INCORRECT) || (rv == CKR_DATA_LEN_RANGE) || (rv == CKR_ARGUMENTS_BAD))
120                plus = "El PIN introducido es incorrecto!";
121            qDebug("%s",  qPrintable("C_login: "  + error + " " +plus));
122            return CK_INVALID_HANDLE;
123        }
124
125    }
126    /*
127    ** Return the session handle and exit
128    */
129    return hSession;
130}
131
132
133
134void CryptoToken::closeSession(CK_SESSION_HANDLE hSession)
135{
136    CK_RV rv;
137    rv = C_CloseSession(hSession);
138    QString error("");
139    if (rv != CKR_OK){
140        qDebug("** Destruyendo ... ~SmartCard");
141        if (rv == CKR_DEVICE_ERROR)
142        {
143            error = returnErrorToQString(rv);
144            qDebug("%s", qPrintable("C_Finalize" + error));
145
146        }
147        error = returnErrorToQString(rv);
148        qDebug("%s", qPrintable("C_Finalize" + error));
149    }
150
151}
152
153
154CK_OBJECT_HANDLE CryptoToken::getPrivateKey(CK_SESSION_HANDLE hSession, CK_SLOT_ID slotID, QString id)
155{
156    QString error("");
157
158    CK_RV rv;
159    CK_OBJECT_HANDLE hObject = CK_INVALID_HANDLE;
160    CK_OBJECT_CLASS objClass = CKO_PRIVATE_KEY;
161    CK_ULONG ulCount = 0;
162
163
164    //CK_BYTE keyid[strlen(id)+1];
165    //strcpy((char *)keyid,id);
166    int idLen = strlen(qPrintable(id))+1;
167
168    CK_UTF8CHAR label[idLen];
169
170    strcpy((char *) label, qPrintable(id));
171    qDebug("SmartCard::getPrivateKey label:");
172    qDebug("%s", (char *) label);
173
174    //qDebug("VALOR DE keyid");
175    //qDebug((char *)keyid);
176
177    CK_ATTRIBUTE privateKeyTemplate[] = {
178        { CKA_CLASS, &objClass, sizeof (objClass) },
179        { CKA_LABEL, label, sizeof(label)-1 }
180        //{CKA_ID, keyid, sizeof (keyid)}
181    };
182
183    CK_ULONG ulTemplateCount = sizeof (privateKeyTemplate) / sizeof (privateKeyTemplate[0]);
184
185    /* Pre-condition checks. */
186    assert (hSession != NULL_PTR);
187
188    // comienza la busqueda de clave privada
189    qDebug ("Inicia busqueda de clave privada ... \n");
190
191    rv = C_FindObjectsInit(hSession, privateKeyTemplate, ulTemplateCount);
192    qDebug ("C_FindObjectsInit rv = %x",rv);
193    qDebug ("\n");
194    //assert(rv==CKR_OK);
195    if (rv != CKR_OK)
196    {
197        error = returnErrorToQString(rv);
198        qDebug("%s", qPrintable("C_FindObjectsInit: "+error));
199        return CK_INVALID_HANDLE;
200
201    }
202
203
204    // se realiza la busqueda
205    rv = C_FindObjects(hSession, &hObject, 1, &ulCount);
206    qDebug ("C_FindObjects rv = %x",rv);
207    qDebug ("\n");
208    //assert(rv==CKR_OK);
209
210    qDebug("*-*-*-*-*getPrivateKey VALOR DE ulCount %u: ", ulCount);
211    //if (rv != CKR_OK)
212    if ((rv != CKR_OK) )//|| (ulCount == 0))
213    {
214        if (ulCount == 0)
215            qDebug("ulCount == 0");
216
217        error = returnErrorToQString(rv);
218        qDebug("%s", qPrintable("C_FindObjects: "+error));
219        return CK_INVALID_HANDLE;
220
221    }
222
223    rv = C_FindObjectsFinal(hSession);
224    qDebug ("C_FindObjectsFinal rv = %x",rv);
225    qDebug ("\n");
226    //assert(rv==CKR_OK);
227    if (rv != CKR_OK)
228    {
229        error = returnErrorToQString(rv);
230        qDebug("%s", qPrintable("C_FindObjectsFinal: "+error));
231        return CK_INVALID_HANDLE;
232    }
233
234    if (ulCount == 0)
235    {
236        qDebug (" \nNinguna clave privada encontrada!\n");
237        // cerrar la sesion
238        /*rv = C_CloseAllSessions(slotID);
239        qDebug("C_CloseAllSessions rv = %x", rv);
240        qDebug ("\n");
241        assert(rv==CKR_OK);*/
242        return CK_INVALID_HANDLE;
243        }
244    else
245    {
246        //qDebug (" \nObjeto encontrado (object=0x%04X)\n", hObject);
247        qDebug (" \nClave privada encontrada:  (clave = 0x%4X)\n", hObject);
248        return hObject;
249    }
250}
251
252
253
254bool CryptoToken::signSomeData(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE privateKey, CK_BYTE_PTR someData,
255        CK_ULONG someDataLen, CK_BYTE_PTR sign, CK_ULONG_PTR signLen )
256{
257    CK_RV rv;
258    qDebug (" \nProceso de firma digital de datos con la clave privada que mantiene la tarjeta...\n");
259    qDebug("valor de sign antes de firmar: \n %s\n", sign);
260
261    //CK_ULONG someDataLen, slen;
262    //someDataLen = strlen((char *) someData);
263
264    //CK_ULONG slen;
265    //slen = BUFFERSIZ;
266    //slen = signLen;
267
268    // definicion del algoritmo de firma
269    CK_MECHANISM signMechanism = { CKM_RSA_PKCS /*CKM_SHA1_RSA_PKCS*/, 0 /*NULL_PTR*/, 0};
270
271    rv = C_SignInit(hSession, &signMechanism, privateKey);
272
273    if (rv != CKR_OK) {
274        qDebug("C_SignInit: rv = 0x%.8X\n", rv);
275        rv = C_CloseSession(hSession);
276        qDebug ("C_CloseSession: rv = %x",rv);
277        qDebug ("\n");
278        assert(rv == CKR_OK);
279        rv = C_Finalize(NULL_PTR);
280        qDebug ("C_Finalize: rv = %x",rv);
281        qDebug ("\n");
282        assert(rv == CKR_OK);
283        return false;
284    }
285
286    qDebug("C_SignInit: rv = 0x%.8X\n", rv);
287    qDebug ("\n");
288    assert(rv==CKR_OK);
289
290    rv = C_Sign(hSession, someData, someDataLen, sign, signLen);
291
292    if (rv != CKR_OK) {
293        qDebug("C_Sign: rv = 0x%.8X\n", rv);
294        rv = C_CloseSession(hSession);
295        qDebug ("C_CloseSession: rv = %x",rv);
296        qDebug ("\n");
297        assert(rv == CKR_OK);
298        rv = C_Finalize(NULL_PTR);
299        qDebug ("C_Finalize: rv = %x",rv);
300        qDebug ("\n");
301        assert(rv == CKR_OK);
302        return false;//1;
303    }
304
305    qDebug("Valor de la firma sign: \n%s\n", sign);
306    qDebug("\nValor de signLen: \n%u\n", *signLen);
307
308    qDebug("C_Sign: rv = 0x%.8X\n", rv);
309    qDebug ("\n");
310    assert(rv==CKR_OK);
311
312
313    qDebug("\nMessage was successfully signed with private key!\n");
314    return true;
315
316}
317
318
319std::vector<unsigned char> CryptoToken::signHash(QString hashToSign, QString pin, QString label)
320{
321
322    std::vector<unsigned char> hash = fromHex(hashToSign);
323
324    QString error("");
325    CK_RV rv;
326
327    CK_SESSION_HANDLE hSession = CK_INVALID_HANDLE;
328    CK_SLOT_ID slotID;
329
330    // initialize criptoki
331    rv = C_Initialize(NULL_PTR);
332    if (rv != CKR_OK)
333    {
334        if (rv == CKR_DEVICE_ERROR)
335        {
336            error = returnErrorToQString(rv);
337            qDebug("%s", qPrintable(error));
338            throw std::runtime_error(qPrintable(error));
339        }
340        error = returnErrorToQString(rv);
341        qDebug("%s", qPrintable(error));
342        throw std::runtime_error(qPrintable(error));
343    }
344
345    hSession = openSession((char *) qPrintable(pin), slotID);
346    if (hSession == CK_INVALID_HANDLE)
347    {
348        qDebug("Fallo ptr_SC->openSession");
349        rv = C_Finalize(NULL_PTR);
350        qDebug("C_Finalize: rv = %x",rv);
351        assert(rv == CKR_OK);
352        throw std::runtime_error("Error openning a session");
353    }
354
355    // obtencion de la clave privada para firmar los datos
356    CK_OBJECT_HANDLE privateKey = CK_INVALID_HANDLE;
357
358    //QString label = "New Key aaraujo";
359    privateKey = getPrivateKey(hSession, slotID, label);
360
361    // https://github.com/open-eid/chrome-token-signing/blob/master/host-shared/PKCS11CardManager.h
362
363    if (privateKey == CK_INVALID_HANDLE)
364    {
365        qDebug("Fallo ptr_SC->getPrivateKey");
366        rv = C_CloseSession(hSession);
367        qDebug("C_CloseSession: rv = %x",rv);
368        assert(rv == CKR_OK);
369        rv = C_Finalize(NULL_PTR);
370        qDebug("C_Finalize: rv = %x",rv);
371        assert(rv == CKR_OK);
372        throw std::runtime_error("Error finding private key");
373    }
374
375    CK_MECHANISM mechanism = {CKM_RSA_PKCS, 0, 0};
376
377
378    rv = C_SignInit(hSession, &mechanism, privateKey);
379
380    if (rv != CKR_OK) {
381        qDebug("C_SignInit: rv = 0x%.8X\n", rv);
382        rv = C_CloseSession(hSession);
383        qDebug ("C_CloseSession: rv = %x",rv);
384        qDebug ("\n");
385        assert(rv == CKR_OK);
386        rv = C_Finalize(NULL_PTR);
387        qDebug ("C_Finalize: rv = %x",rv);
388        qDebug ("\n");
389        assert(rv == CKR_OK);
390        throw std::runtime_error("Error C_SignInit");
391    }
392
393    qDebug("C_SignInit: rv = 0x%.8X\n", rv);
394    qDebug ("\n");
395    assert(rv==CKR_OK);
396
397    std::vector<unsigned char> hashWithPadding;
398    switch (hash.size()) {
399        case BINARY_SHA1_LENGTH:
400            hashWithPadding = {0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14};
401            break;
402        case BINARY_SHA224_LENGTH:
403            hashWithPadding = {0x30, 0x2d, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04, 0x1c};
404            break;
405        case BINARY_SHA256_LENGTH:
406            hashWithPadding = {0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20};
407            break;
408        case BINARY_SHA384_LENGTH:
409            hashWithPadding = {0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05, 0x00, 0x04, 0x30};
410            break;
411        case BINARY_SHA512_LENGTH:
412            hashWithPadding = {0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05, 0x00, 0x04, 0x40};
413            break;
414        default:
415            throw std::runtime_error("incorrect digest length, dropping padding");
416    }
417    hashWithPadding.insert(hashWithPadding.end(), hash.begin(), hash.end());
418
419    CK_ULONG signatureLength = 0;
420
421
422    rv = C_Sign(hSession, hashWithPadding.data(), hashWithPadding.size(), nullptr, &signatureLength);
423
424    if (rv != CKR_OK) {
425        qDebug("C_Sign: rv = 0x%.8X\n", rv);
426        rv = C_CloseSession(hSession);
427        qDebug ("C_CloseSession: rv = %x",rv);
428        qDebug ("\n");
429        assert(rv == CKR_OK);
430        rv = C_Finalize(NULL_PTR);
431        qDebug ("C_Finalize: rv = %x",rv);
432        qDebug ("\n");
433        assert(rv == CKR_OK);
434        throw std::runtime_error("Error C_Sign1");
435    }
436
437    std::vector<unsigned char> signature(signatureLength, 0);
438
439    rv = C_Sign(hSession, hashWithPadding.data(), hashWithPadding.size(), signature.data(), &signatureLength);
440
441    if (rv != CKR_OK) {
442        qDebug("C_Sign: rv = 0x%.8X\n", rv);
443        rv = C_CloseSession(hSession);
444        qDebug ("C_CloseSession: rv = %x",rv);
445        qDebug ("\n");
446        assert(rv == CKR_OK);
447        rv = C_Finalize(NULL_PTR);
448        qDebug ("C_Finalize: rv = %x",rv);
449        qDebug ("\n");
450        assert(rv == CKR_OK);
451        throw std::runtime_error("Error C_Sign2");
452    }
453
454
455    qDebug("C_Sign: rv = 0x%.8X\n", rv);
456    qDebug ("\n");
457    assert(rv==CKR_OK);
458
459    closeSession(hSession);
460    finalize();
461
462    return signature;
463
464}
465
466/*
467std::vector<CK_OBJECT_HANDLE> CryptoToken::findObject(CK_OBJECT_CLASS objectClass, CK_ULONG max = 2) const {
468    if (!fl) {
469        throw std::runtime_error("PKCS11 is not loaded");
470    }
471    CK_ATTRIBUTE searchAttribute = {CKA_CLASS, &objectClass, sizeof(objectClass)};
472
473
474
475    C(FindObjectsInit, session, &searchAttribute, 1);
476    CK_ULONG objectCount = max;
477    std::vector<CK_OBJECT_HANDLE> objectHandle(objectCount);
478    C(FindObjects, session, objectHandle.data(), objectHandle.size(), &objectCount);
479    C(FindObjectsFinal, session);
480    objectHandle.resize(objectCount);
481    return objectHandle;
482}
483*/
484
485QStringList CryptoToken::getPrivateKeyLabels(QString pin)
486{
487    qDebug("...CryptoToken::getPrivateKeyLabels");
488    QStringList list;
489
490    QString error("");
491    CK_RV rv;
492
493    CK_SESSION_HANDLE hSession = CK_INVALID_HANDLE;
494    CK_SLOT_ID slotID;
495
496    // initialize criptoki
497    rv = C_Initialize(NULL_PTR);
498    if (rv != CKR_OK)
499    {
500        if (rv == CKR_DEVICE_ERROR)
501        {
502            error = returnErrorToQString(rv);
503            qDebug("%s", qPrintable(error));
504            throw std::runtime_error(qPrintable(error));
505        }
506        error = returnErrorToQString(rv);
507        qDebug("%s", qPrintable(error));
508        throw std::runtime_error(qPrintable(error));
509    }
510
511    hSession = openSession((char *) qPrintable(pin), slotID);
512    if (hSession == CK_INVALID_HANDLE)
513    {
514        qDebug("Fallo ptr_SC->openSession");
515        rv = C_Finalize(NULL_PTR);
516        qDebug("C_Finalize: rv = %x",rv);
517        assert(rv == CKR_OK);
518        throw std::runtime_error("Error openning a session");
519    }
520
521    CK_OBJECT_CLASS objectClass = CKO_PRIVATE_KEY;
522    //CK_OBJECT_CLASS objectClass = CKO_PUBLIC_KEY;
523    //CK_OBJECT_CLASS objectClass = CKO_CERTIFICATE;
524
525    CK_OBJECT_HANDLE hObject = CK_INVALID_HANDLE;
526    CK_ATTRIBUTE searchAttribute = {CKA_CLASS, &objectClass, sizeof(objectClass)};
527    CK_ULONG ulCount = 0;
528
529    rv = C_FindObjectsInit(hSession, &searchAttribute, 1);
530    qDebug ("C_FindObjectsInit rv = %x",rv);
531    qDebug ("\n");
532    //assert(rv==CKR_OK);
533    if (rv != CKR_OK)
534    {
535        error = returnErrorToQString(rv);
536        qDebug("%s", qPrintable("C_FindObjectsInit: "+error));
537        //return list;
538        throw std::runtime_error(qPrintable(error));
539    }
540
541    CK_ULONG objectCount = 3;
542    std::vector<CK_OBJECT_HANDLE> objectHandle(objectCount);
543
544    // se realiza la busqueda
545    //rv = C_FindObjects(hSession, &hObject, 2, &ulCount);
546    rv = C_FindObjects(hSession, objectHandle.data(), objectHandle.size(), &objectCount);
547
548    qDebug ("C_FindObjects rv = %x",rv);
549    qDebug ("\n");
550    //assert(rv==CKR_OK);
551
552    qDebug("*-*-*-*-*getPrivateKeyLabels VALOR DE objectCount %u: ", objectCount);
553    //if (rv != CKR_OK)
554    if ((rv != CKR_OK) )//|| (ulCount == 0))
555    {
556        if (ulCount == 0)
557            qDebug("ulCount == 0");
558
559        error = returnErrorToQString(rv);
560        qDebug("%s", qPrintable("C_FindObjects: "+error));
561        //return list;
562        throw std::runtime_error(qPrintable(error));
563    }
564
565    rv = C_FindObjectsFinal(hSession);
566    qDebug ("C_FindObjectsFinal rv = %x",rv);
567    qDebug ("\n");
568    //assert(rv==CKR_OK);
569    if (rv != CKR_OK)
570    {
571        error = returnErrorToQString(rv);
572        qDebug("%s", qPrintable("C_FindObjectsFinal: "+error));
573        //return list;
574        throw std::runtime_error(qPrintable(error));
575    }
576    objectHandle.resize(objectCount);
577
578    //if (ulCount == 0)
579    if (objectHandle.size() == 0)
580    {
581        qDebug (" \nNingun objeto encontrado!\n");
582        // cerrar la sesion
583        /*rv = C_CloseAllSessions(slotID);
584        qDebug("C_CloseAllSessions rv = %x", rv);
585        qDebug ("\n");
586        assert(rv==CKR_OK);*/
587        //return list;
588        throw std::runtime_error(qPrintable(error));
589        }
590    else
591    {
592        //qDebug (" \nObjeto encontrado (object=0x%04X)\n", hObject);
593        qDebug("se econtraron %d objetos", objectHandle.size());
594        //qDebug (" \nClave privada encontrada:  (clave = 0x%4X)\n", hObject);
595        for (int i=0; i< objectHandle.size(); i++)
596        {
597            qDebug("objeto encontrado: 0x%4X", objectHandle[i]);
598            list.append(getKeyLabel(hSession, objectHandle[i]));
599        }
600    }
601
602    closeSession(hSession);
603    finalize();
604
605    return list;
606}
607
608QString CryptoToken::getKeyLabel(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE key)
609{
610    qDebug("CryptoToken::getKeyLabel");
611
612    CK_RV rv = CKR_OK;
613    CK_ATTRIBUTE keyid_attr[1] = {
614        { CKA_LABEL, NULL, 0 }
615        //{ CKA_VALUE, NULL, 0 }
616    };
617
618    if ((rv = C_GetAttributeValue(hSession, key, keyid_attr, 1)) != CKR_OK)
619    {
620        //QMessageBox::critical(this,tr("UserAccess"),tr("fallo la obtencion del atributo ID"));
621        qDebug("fallo la obtencion del atributo ID");
622        return "";
623    }
624
625    if ((keyid_attr[0].pValue = malloc(keyid_attr[0].ulValueLen)) == NULL)
626    {
627        //QMessageBox::critical(this,tr("UserAccess"),tr("fallo la asignacion de memoria del atributo ID"));
628        qDebug("fallo la asignacion de memoria del atributo ID");
629        return "";
630    }
631    if ((rv = C_GetAttributeValue(hSession, key, keyid_attr, 1)) != CKR_OK)
632    {
633        //QMessageBox::critical(this,tr("UserAccess"),tr("fallo la obtencion 2 del atributo ID"));
634        qDebug("fallo la obtencion 2 del atributo ID");
635        return "";
636    }
637
638    //qDebug("\n*-** VALOR DE ID: %s\n", keyid_attr[0].pValue);
639    qDebug("\n*-** VALOR DE atributo: %s\n", keyid_attr[0].pValue);
640    QString label = (const char *) keyid_attr[0].pValue;
641
642    qDebug("%s", qPrintable(label));
643    qDebug("%s", qPrintable(QString::number(label.size())));
644
645    return label;
646}
647
648
649QList<QStringList> CryptoToken::getCertificateCNandExpirationDate(QString pin)
650{
651    qDebug("...CryptoToken::getCertificateCNandExpirationDate");
652    QList<QStringList> list;
653
654    QString error("");
655    CK_RV rv;
656
657    CK_SESSION_HANDLE hSession = CK_INVALID_HANDLE;
658    CK_SLOT_ID slotID;
659
660    // initialize criptoki
661    rv = C_Initialize(NULL_PTR);
662    if (rv != CKR_OK)
663    {
664        if (rv == CKR_DEVICE_ERROR)
665        {
666            qDebug("CKR_DEVICE_ERROR");
667            error = returnErrorToQString(rv);
668            qDebug("%s", qPrintable(error));
669            throw std::runtime_error(qPrintable(error));
670        }
671        qDebug("****");
672        error = returnErrorToQString(rv);
673        qDebug("%s", qPrintable(error));
674        throw std::runtime_error(qPrintable(error));
675    }
676
677    hSession = openSession((char *) qPrintable(pin), slotID);
678    if (hSession == CK_INVALID_HANDLE)
679    {
680        qDebug("Fallo ptr_SC->openSession");
681        rv = C_Finalize(NULL_PTR);
682        qDebug("C_Finalize: rv = %x",rv);
683        assert(rv == CKR_OK);
684        throw std::runtime_error("Error openning a session inside the device");
685    }
686
687    CK_OBJECT_CLASS objectClass = CKO_CERTIFICATE;
688
689    CK_OBJECT_HANDLE hObject = CK_INVALID_HANDLE;
690    CK_ATTRIBUTE searchAttribute = {CKA_CLASS, &objectClass, sizeof(objectClass)};
691    CK_ULONG ulCount = 0;
692
693    rv = C_FindObjectsInit(hSession, &searchAttribute, 1);
694    qDebug ("C_FindObjectsInit rv = %x",rv);
695    qDebug ("\n");
696    //assert(rv==CKR_OK);
697    if (rv != CKR_OK)
698    {
699        error = returnErrorToQString(rv);
700        qDebug("%s", qPrintable("C_FindObjectsInit: "+error));
701        //return list;
702        throw std::runtime_error(qPrintable(error));
703    }
704
705    CK_ULONG objectCount = 3;
706    std::vector<CK_OBJECT_HANDLE> objectHandle(objectCount);
707
708    // se realiza la busqueda
709    //rv = C_FindObjects(hSession, &hObject, 2, &ulCount);
710    rv = C_FindObjects(hSession, objectHandle.data(), objectHandle.size(), &objectCount);
711
712    qDebug ("C_FindObjects rv = %x",rv);
713    qDebug ("\n");
714    //assert(rv==CKR_OK);
715
716    qDebug("*-*-*-*-*getPrivateKeyLabels VALOR DE objectCount %u: ", objectCount);
717    //if (rv != CKR_OK)
718    if ((rv != CKR_OK) )//|| (ulCount == 0))
719    {
720        if (ulCount == 0)
721            qDebug("ulCount == 0");
722
723        error = returnErrorToQString(rv);
724        qDebug("%s", qPrintable("C_FindObjects: "+error));
725        //return list;
726        throw std::runtime_error(qPrintable(error));
727    }
728
729    rv = C_FindObjectsFinal(hSession);
730    qDebug ("C_FindObjectsFinal rv = %x",rv);
731    qDebug ("\n");
732    //assert(rv==CKR_OK);
733    if (rv != CKR_OK)
734    {
735        error = returnErrorToQString(rv);
736        qDebug("%s", qPrintable("C_FindObjectsFinal: "+error));
737        //return list;
738        throw std::runtime_error(qPrintable(error));
739    }
740    objectHandle.resize(objectCount);
741
742    //if (ulCount == 0)
743    if (objectHandle.size() == 0)
744    {
745        qDebug (" \nNingun objeto encontrado!\n");
746        // cerrar la sesion
747        /*rv = C_CloseAllSessions(slotID);
748        qDebug("C_CloseAllSessions rv = %x", rv);
749        qDebug ("\n");
750        assert(rv==CKR_OK);*/
751        //return list;
752        throw std::runtime_error(qPrintable(error));
753        }
754    else
755    {
756        //qDebug (" \nObjeto encontrado (object=0x%04X)\n", hObject);
757        qDebug("se econtraron %d objetos", objectHandle.size());
758        //qDebug (" \nClave privada encontrada:  (clave = 0x%4X)\n", hObject);
759
760        for (int i=0; i< objectHandle.size(); i++)
761        {
762            QStringList certInformation;
763            qDebug("objeto encontrado: 0x%4X", objectHandle[i]);
764            certInformation = getCertificateInformation(hSession, objectHandle[i]);
765            //list.append(getCertificateInformation(hSession, objectHandle[i])[0]);
766            //list.append(getCertificateInformation(hSession, objectHandle[i])[0]);
767            list.append(certInformation);
768        }
769    }
770
771    closeSession(hSession);
772    finalize();
773
774    return list;
775}
776
777QStringList CryptoToken::getCertificateInformation(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE certificate)
778{
779    qDebug("...getCertificateInformation...");
780
781    CK_RV rv = CKR_OK;
782    CK_ATTRIBUTE keyid_attr[2] = {
783        { CKA_LABEL, NULL, 0 },
784        { CKA_VALUE, NULL, 0 }
785    };
786
787    QStringList list;
788
789
790    if ((rv = C_GetAttributeValue(hSession, certificate, keyid_attr, 2)) != CKR_OK)
791    {
792        //QMessageBox::critical(this,tr("UserAccess"),tr("fallo la obtencion del atributo ID"));
793        qDebug("fallo la obtencion del atributo ID");
794        return list;
795    }
796
797    if ((keyid_attr[1].pValue = malloc(keyid_attr[1].ulValueLen)) == NULL)
798    {
799        //QMessageBox::critical(this,tr("UserAccess"),tr("fallo la asignacion de memoria del atributo ID"));
800        qDebug("fallo la asignacion de memoria del atributo ID");
801        return list;
802    }
803    if ((rv = C_GetAttributeValue(hSession, certificate, keyid_attr, 2)) != CKR_OK)
804    {
805        //QMessageBox::critical(this,tr("UserAccess"),tr("fallo la obtencion 2 del atributo ID"));
806        qDebug("fallo la obtencion 2 del atributo ID");
807        return list;
808    }
809
810    //qDebug("\n*-** VALOR DE ID: %s\n", keyid_attr[0].pValue);
811    //qDebug("\n*-** VALOR DE atributo: %s\n", keyid_attr[1].pValue);
812    //QString x = (const char *) keyid_attr[1].pValue;
813
814    //qDebug(qPrintable(x));
815    //qDebug(qPrintable(QString::number(x.size())));
816
817
818    //qDebug("prueba de generar un QSslCertificate");
819
820    QSslCertificate qcert(QByteArray((const char *) keyid_attr[1].pValue, (int) keyid_attr[1].ulValueLen), QSsl::Der);
821
822    if (qcert.isNull()){
823        qDebug("qcert es null");
824    }
825
826    //qDebug("mira el contenido qcert");
827
828    /*
829    QStringList list = qcert.subjectInfo(QSslCertificate::EmailAddress);
830    QStringList l2 = qcert.subjectInfo(QSslCertificate::DistinguishedNameQualifier);
831    QStringList l3 = qcert.subjectInfo( QSslCertificate::CommonName );
832    QStringList l4 = qcert.subjectInfo( QSslCertificate::Organization );
833    QStringList l5 = qcert.subjectInfo( QSslCertificate::LocalityName );
834    QStringList l6 = qcert.subjectInfo( QSslCertificate::OrganizationalUnitName );
835    QStringList l7 = qcert.subjectInfo( QSslCertificate::StateOrProvinceName );
836    */
837    list.append(qcert.subjectInfo( QSslCertificate::CommonName ));
838    list.append(qcert.expiryDate().date().toString("dd.MM.yyyy"));
839
840    //qDebug(qPrintable(qcert.effectiveDate().date().toString("dd.MM.yyyy")));
841    //qDebug(qPrintable(qcert.expiryDate().date().toString("dd.MM.yyyy")));
842
843    return list;
844}
845
846
847QList<QStringList> CryptoToken::getDeviceCertificates(QString pin)
848{
849    qDebug("...getDeviceCertificates");
850
851
852    QStringList labelList = getPrivateKeyLabels(pin);
853
854    QList<QStringList> nameExpirationList = getCertificateCNandExpirationDate(pin);
855
856    QList<QStringList> certificateInformationList;
857
858    for (int i=0; i<labelList.size(); i++)
859    {
860        QStringList l;
861        qDebug("... antes de insertar label");
862        l.append(labelList[i]);
863        qDebug("... antes de insertar commonName");
864        l.append(nameExpirationList[i][0]);
865        qDebug("... antes de insertar expirationDate");
866        l.append(nameExpirationList[i][1]);
867
868        qDebug("... antes de insertar en certificateInformationList");
869        certificateInformationList.append(l);
870    }
871
872    return certificateInformationList;
873}
874
875
876void CryptoToken::getCertificateAttributes(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hCert)
877{
878   CK_ATTRIBUTE pTemplate[2] = {
879       //List your desired attributes here
880       { CKA_LABEL, NULL, 0 }
881       //{ CKA_LABEL, NULL, 0 }
882   };
883
884   CK_RV rv = C_GetAttributeValue(hSession, hCert, pTemplate, /*pTemplateLen*/ 2);
885   if (rv == CKR_OK) {
886       //here you have your desired certificate attributes
887       qDebug("chequea los atributos");
888
889   }
890}
891
892
893
894
895
896
897
898
899
900
901
902// slot para obtener informacion del modulo PKCS11
903QString CryptoToken::getInfoCryptoki()
904{
905    // Generales
906    //if ( !CHECKACCESS_ONE("smartcard information", "execute") ) return;
907    CK_INFO info;
908
909    /* Valor devuelto por las funciones */
910    CK_RV rv;
911
912    QString error("");
913    QString mensaje;
914    mensaje.clear();
915
916    rv = C_Initialize(NULL_PTR);
917
918    //fqDebug(stderr, "C_Initialize: rv = 0x%.8X\n", rv);
919    //cout << "valor decimal de rv: " << rv ;
920
921    //assert(rv == CKR_OK);
922    //mensaje->append("C_Initialize\n");
923    if (rv != CKR_OK)
924    {
925
926        if (rv == CKR_DEVICE_ERROR)
927        {
928            error = returnErrorToQString(rv);
929            qDebug("Probablemente el lector no este conectado");
930            return error;
931        }
932        error = returnErrorToQString(rv);
933        qDebug("valor de x despues de returnError: %s", qPrintable(error));
934        return error;
935    }
936
937
938    rv = C_GetInfo(&info);
939    //fqDebug(stderr, "C_GetInfo: rv = 0x%.8X\n", rv);
940    //cout << "valor decimal de rv: " << rv ;
941
942    if (rv != CKR_OK)
943    {
944        error = returnErrorToQString(rv);
945        return error;
946    }
947    //assert(rv == CKR_OK);
948
949    QString y("Descripcion: ");
950    y.append((const char *) info.libraryDescription);
951    mensaje.append(y);
952
953    QString x("Fabricante: ");
954    x.append((const char *) info.manufacturerID);
955    mensaje.append(x);
956
957    QString cryptokiVersion("Version: ");
958    cryptokiVersion.append(QString::number(info.cryptokiVersion.major));
959    cryptokiVersion.append(".");
960    cryptokiVersion.append(QString::number(info.cryptokiVersion.minor));
961    qDebug("%s", qPrintable(cryptokiVersion));
962    mensaje.append(cryptokiVersion);
963
964    rv = C_Finalize(NULL_PTR);
965    if (rv != CKR_OK)
966    {
967        error = returnErrorToQString(rv);
968        return error;
969    }
970    assert(rv == CKR_OK);
971    //mensaje->append("C_Finalize\n");
972
973    //qDebug("***********************mensaje:");
974    //qDebug(qPrintable(mensaje));
975    return mensaje;
976}
977
978
979
980
981QString CryptoToken::returnErrorToQString(CK_RV rv)
982{
983    QString x("");
984    qDebug("returnErrorToQString");
985    //qDebug("valor de x: ", x);
986    //qDebug("valor de rv: "+ QString::number(rv,16));
987
988    /* CK_RV is a value that identifies the return value of a
989    * Cryptoki function */
990    /* CK_RV was changed from CK_USHORT to CK_ULONG for v2.0 */
991    //typedef CK_ULONG          CK_RV;
992
993    if (rv == CKR_OK) // CKR_OK 0x00000000
994    {
995        x = "CKR_OK";
996    } else if (rv == CKR_CANCEL)  // CKR_CANCEL 0x00000001
997    {
998        x = "CKR_CANCEL";
999    } else if (rv == CKR_HOST_MEMORY) //CKR_HOST_MEMORY 0x00000002
1000    {
1001        x = "CKR_HOST_MEMORY";
1002    } else if (rv == CKR_SLOT_ID_INVALID) //CKR_SLOT_ID_INVALID 0x00000003
1003    {
1004        x = "CKR_SLOT_ID_INVALID";
1005    }
1006    /* CKR_FLAGS_INVALID was removed for v2.0 */
1007    /* CKR_GENERAL_ERROR and CKR_FUNCTION_FAILED are new for v2.0 */
1008    else if (rv == CKR_GENERAL_ERROR)           //CKR_GENERAL_ERROR 0x00000005
1009    {
1010        x = "CKR_GENERAL_ERROR";
1011    } else if (rv == CKR_FUNCTION_FAILED)    //CKR_FUNCTION_FAILED 0x00000006
1012    {
1013        x = "CKR_FUNCTION_FAILED";
1014        return x;
1015    }
1016    /* CKR_ARGUMENTS_BAD, CKR_NO_EVENT, CKR_NEED_TO_CREATE_THREADS,
1017    * and CKR_CANT_LOCK are new for v2.01 */
1018    else if (rv == CKR_ARGUMENTS_BAD)       // CKR_ARGUMENTS_BAD 0x00000007
1019    {
1020        x = "CKR_ARGUMENTS_BAD";
1021    } else if (rv == CKR_NO_EVENT) //CKR_NO_EVENT                          0x00000008
1022    {
1023        x = "CKR_NO_EVENT";
1024    } else if (rv == CKR_NEED_TO_CREATE_THREADS) //CKR_NEED_TO_CREATE_THREADS            0x00000009
1025    {
1026        x = "CKR_NEED_TO_CREATE_THREADS";
1027    } else if (rv == CKR_CANT_LOCK) // CKR_CANT_LOCK                         0x0000000A
1028    {
1029        x = "CKR_CANT_LOCK";
1030    } else if (rv == CKR_ATTRIBUTE_READ_ONLY) // CKR_ATTRIBUTE_READ_ONLY               0x00000010
1031    {
1032        x = "CKR_ATTRIBUTE_READ_ONLY";
1033    } else if (rv == CKR_ATTRIBUTE_SENSITIVE) // CKR_ATTRIBUTE_SENSITIVE               0x00000011
1034    {
1035        x = "CKR_ATTRIBUTE_SENSITIVE";
1036    } else if (rv == CKR_ATTRIBUTE_TYPE_INVALID) // CKR_ATTRIBUTE_TYPE_INVALID            0x00000012
1037    {
1038        x = "CKR_ATTRIBUTE_TYPE_INVALID";
1039        return x;
1040    } else if (rv == CKR_ATTRIBUTE_VALUE_INVALID)// CKR_ATTRIBUTE_VALUE_INVALID           0x00000013
1041    {
1042        x = "CKR_ATTRIBUTE_VALUE_INVALID";
1043    } else if (rv == CKR_DATA_INVALID)//#define CKR_DATA_INVALID                      0x00000020
1044    {
1045        x = "CKR_DATA_INVALID";
1046    } else if (rv == CKR_DATA_LEN_RANGE) //#define CKR_DATA_LEN_RANGE                    0x00000021
1047    {
1048        x = "CKR_DATA_LEN_RANGE";
1049    } else if (rv == CKR_DEVICE_ERROR) //#define CKR_DEVICE_ERROR                      0x00000030
1050    {
1051        x = "CKR_DEVICE_ERROR";
1052        qDebug("FUCK");
1053    } else if (rv == CKR_DEVICE_MEMORY) //#define CKR_DEVICE_MEMORY                     0x00000031
1054    {
1055        x = "CKR_DEVICE_MEMORY";
1056
1057    } else if (rv == CKR_DEVICE_REMOVED) //#define CKR_DEVICE_REMOVED                    0x00000032
1058    {
1059        x = "CKR_DEVICE_REMOVED";
1060    } else if (rv == CKR_ENCRYPTED_DATA_INVALID) //#define CKR_ENCRYPTED_DATA_INVALID            0x00000040
1061    {
1062        x = "CKR_ENCRYPTED_DATA_INVALID";
1063    } else if (rv == CKR_ENCRYPTED_DATA_LEN_RANGE) //#define CKR_ENCRYPTED_DATA_LEN_RANGE          0x00000041
1064    {
1065        x = "CKR_ENCRYPTED_DATA_LEN_RANGE";
1066    } else if (rv == CKR_FUNCTION_CANCELED) //#define CKR_FUNCTION_CANCELED                 0x00000050
1067    {
1068        x = "CKR_FUNCTION_CANCELED";
1069    } else if (rv == CKR_FUNCTION_NOT_PARALLEL) //#define CKR_FUNCTION_NOT_PARALLEL             0x00000051
1070    {
1071        x = "CKR_FUNCTION_NOT_PARALLEL";
1072    }
1073    /* CKR_FUNCTION_NOT_SUPPORTED is new for v2.0 */
1074    else if (rv == CKR_FUNCTION_NOT_SUPPORTED) //#define CKR_FUNCTION_NOT_SUPPORTED            0x00000054
1075    {
1076        x = "CKR_FUNCTION_NOT_SUPPORTED";
1077    } else if (rv == CKR_KEY_HANDLE_INVALID) //#define CKR_KEY_HANDLE_INVALID                0x00000060
1078    {
1079        x = "CKR_KEY_HANDLE_INVALID";
1080    }
1081    /* CKR_KEY_SENSITIVE was removed for v2.0 */
1082    else if (rv == CKR_KEY_SIZE_RANGE)     //#define CKR_KEY_SIZE_RANGE                    0x00000062
1083    {
1084        x = "CKR_KEY_SIZE_RANGE";
1085    } else if (rv == CKR_KEY_TYPE_INCONSISTENT)//#define CKR_KEY_TYPE_INCONSISTENT             0x00000063
1086    {
1087        x = "CKR_KEY_TYPE_INCONSISTENT";
1088    }
1089    /* CKR_KEY_NOT_NEEDED, CKR_KEY_CHANGED, CKR_KEY_NEEDED,
1090    * CKR_KEY_INDIGESTIBLE, CKR_KEY_FUNCTION_NOT_PERMITTED,
1091    * CKR_KEY_NOT_WRAPPABLE, and CKR_KEY_UNEXTRACTABLE are new for
1092    * v2.0 */
1093    else if (rv == CKR_KEY_NOT_NEEDED) //#define CKR_KEY_NOT_NEEDED                    0x00000064
1094    {
1095        x = "CKR_KEY_NOT_NEEDED";
1096    } else if (rv == CKR_KEY_CHANGED) //#define CKR_KEY_CHANGED                       0x00000065
1097    {
1098        x = "CKR_KEY_CHANGED";
1099    } else if (rv == CKR_KEY_NEEDED) //#define CKR_KEY_NEEDED                        0x00000066
1100    {
1101        x = "CKR_KEY_NEEDED";
1102    } else if (rv == CKR_KEY_INDIGESTIBLE)//#define CKR_KEY_INDIGESTIBLE                  0x00000067
1103    {
1104        x = "CKR_KEY_INDIGESTIBLE";
1105    } else if (rv == CKR_KEY_FUNCTION_NOT_PERMITTED)//#define CKR_KEY_FUNCTION_NOT_PERMITTED        0x00000068
1106    {
1107        x = "CKR_KEY_FUNCTION_NOT_PERMITTED";
1108    } else if (rv == CKR_KEY_NOT_WRAPPABLE)//#define CKR_KEY_NOT_WRAPPABLE                 0x00000069
1109    {
1110        x = "CKR_KEY_NOT_WRAPPABLE";
1111    } else if (rv == CKR_KEY_UNEXTRACTABLE)//#define CKR_KEY_UNEXTRACTABLE                 0x0000006A
1112    {
1113        x = "CKR_KEY_UNEXTRACTABLE";
1114    } else if (rv == CKR_MECHANISM_INVALID)//#define CKR_MECHANISM_INVALID                 0x00000070
1115    {
1116        x = "CKR_SLOTCKR_MECHANISM_INVALID";
1117    } else if (rv == CKR_MECHANISM_PARAM_INVALID)//#define CKR_MECHANISM_PARAM_INVALID           0x00000071
1118    {
1119        x = "CKR_MECHANISM_PARAM_INVALID";
1120    }
1121    /* CKR_OBJECT_CLASS_INCONSISTENT and CKR_OBJECT_CLASS_INVALID
1122    * were removed for v2.0 */
1123    else if (rv == CKR_OBJECT_HANDLE_INVALID)//#define CKR_OBJECT_HANDLE_INVALID             0x00000082
1124    {
1125        x = "CKR_OBJECT_HANDLE_INVALID";
1126    } else if (rv == CKR_OPERATION_ACTIVE)//#define CKR_OPERATION_ACTIVE                  0x00000090
1127    {
1128        x = "CKR_OPERATION_ACTIVE";
1129    } else if (rv == CKR_OPERATION_NOT_INITIALIZED)//#define CKR_OPERATION_NOT_INITIALIZED         0x00000091
1130    {
1131        x = "CKR_OPERATION_NOT_INITIALIZED";
1132    } else if (rv == CKR_PIN_INCORRECT)//#define CKR_PIN_INCORRECT                     0x000000A0
1133    {
1134        x = "CKR_PIN_INCORRECT";
1135    } else if (rv == CKR_PIN_INVALID)//#define CKR_PIN_INVALID                       0x000000A1
1136    {
1137        x = "CKR_PIN_INVALID";
1138    } else if (rv == CKR_PIN_LEN_RANGE)//#define CKR_PIN_LEN_RANGE                     0x000000A2
1139    {
1140        x = "CKR_PIN_LEN_RANGE";
1141    } /* CKR_PIN_EXPIRED and CKR_PIN_LOCKED are new for v2.0 */
1142    else if (rv == CKR_PIN_EXPIRED)//#define CKR_PIN_EXPIRED                       0x000000A3
1143    {
1144        x = "CKR_PIN_EXPIRED";
1145    } else if (rv == CKR_PIN_LOCKED)//#define CKR_PIN_LOCKED                        0x000000A4
1146    {
1147        x = "CKR_PIN_LOCKED";
1148    } else if (rv == CKR_SESSION_CLOSED)//#define CKR_SESSION_CLOSED                    0x000000B0
1149    {
1150        x = "CKR_SESSION_CLOSED";
1151    } else if (rv == CKR_SESSION_COUNT)//#define CKR_SESSION_COUNT                     0x000000B1
1152    {
1153        x = "CKR_SESSION_COUNT";
1154    } else if (rv == CKR_SESSION_HANDLE_INVALID)//#define CKR_SESSION_HANDLE_INVALID            0x000000B3
1155    {
1156        x = "CKR_SESSION_HANDLE_INVALID";
1157    } else if (rv == CKR_SESSION_PARALLEL_NOT_SUPPORTED)//#define CKR_SESSION_PARALLEL_NOT_SUPPORTED    0x000000B4
1158    {
1159        x = "CKR_SESSION_PARALLEL_NOT_SUPPORTED";
1160    } else if (rv == CKR_SESSION_READ_ONLY)//#define CKR_SESSION_READ_ONLY                 0x000000B5
1161    {
1162        x = "CKR_SESSION_READ_ONLY";
1163    } else if (rv == CKR_SESSION_EXISTS)//#define CKR_SESSION_EXISTS                    0x000000B6
1164    {
1165        x = "CKR_SESSION_EXISTS";
1166    }
1167    /* CKR_SESSION_READ_ONLY_EXISTS and
1168    * CKR_SESSION_READ_WRITE_SO_EXISTS are new for v2.0 */
1169
1170    else if (rv == CKR_SESSION_READ_ONLY_EXISTS)//#define CKR_SESSION_READ_ONLY_EXISTS          0x000000B7
1171    {
1172        x = "CKR_SESSION_READ_ONLY_EXISTS";
1173    } else if (rv == CKR_SESSION_READ_WRITE_SO_EXISTS)//#define CKR_SESSION_READ_WRITE_SO_EXISTS      0x000000B8
1174    {
1175        x = "CKR_SESSION_READ_WRITE_SO_EXISTS";
1176    } else if (rv == CKR_SIGNATURE_INVALID)//#define CKR_SIGNATURE_INVALID                 0x000000C0
1177    {
1178        x = "CKR_SIGNATURE_INVALID";
1179    } else if (rv == CKR_SIGNATURE_LEN_RANGE)//#define CKR_SIGNATURE_LEN_RANGE               0x000000C1
1180    {
1181        x = "CKR_SIGNATURE_LEN_RANGE";
1182    } else if (rv == CKR_TEMPLATE_INCOMPLETE)//#define CKR_TEMPLATE_INCOMPLETE               0x000000D0
1183    {
1184        x = "CKR_TEMPLATE_INCOMPLETE";
1185    } else if (rv == CKR_TEMPLATE_INCONSISTENT)//#define CKR_TEMPLATE_INCONSISTENT             0x000000D1
1186    {
1187        x = "CKR_TEMPLATE_INCONSISTENT";
1188    } else if (rv == CKR_TOKEN_NOT_PRESENT)//#define CKR_TOKEN_NOT_PRESENT                 0x000000E0
1189    {
1190        x = "CKR_TOKEN_NOT_PRESENT";
1191    } else if (rv == CKR_TOKEN_NOT_RECOGNIZED)//#define CKR_TOKEN_NOT_RECOGNIZED              0x000000E1
1192    {
1193        x = "CKR_TOKEN_NOT_RECOGNIZED";
1194    } else if (rv == CKR_TOKEN_WRITE_PROTECTED)//#define CKR_TOKEN_WRITE_PROTECTED             0x000000E2
1195    {
1196        x = "CKR_TOKEN_WRITE_PROTECTED";
1197    } else if (rv == CKR_UNWRAPPING_KEY_HANDLE_INVALID)//#define CKR_UNWRAPPING_KEY_HANDLE_INVALID     0x000000F0
1198    {
1199        x = "CKR_UNWRAPPING_KEY_HANDLE_INVALID";
1200    } else if (rv == CKR_UNWRAPPING_KEY_SIZE_RANGE)//#define CKR_UNWRAPPING_KEY_SIZE_RANGE         0x000000F1
1201    {
1202        x = "CKR_UNWRAPPING_KEY_SIZE_RANGE";
1203    } else if (rv == CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT)//#define CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT  0x000000F2
1204    {
1205        x = "CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT";
1206    } else if (rv == CKR_USER_ALREADY_LOGGED_IN)//#define CKR_USER_ALREADY_LOGGED_IN            0x00000100
1207    {
1208        x = "CKR_USER_ALREADY_LOGGED_IN";
1209    } else if (rv == CKR_USER_NOT_LOGGED_IN)//#define CKR_USER_NOT_LOGGED_IN                0x00000101
1210    {
1211        x = "CKR_USER_NOT_LOGGED_IN";
1212    } else if (rv == CKR_USER_PIN_NOT_INITIALIZED)//#define CKR_USER_PIN_NOT_INITIALIZED          0x00000102
1213    {
1214        x = "CKR_USER_PIN_NOT_INITIALIZED";
1215    } else if (rv == CKR_USER_TYPE_INVALID)//#define CKR_USER_TYPE_INVALID                 0x00000103
1216    {
1217        x = "CKR_USER_TYPE_INVALID";
1218    }
1219    /* CKR_USER_ANOTHER_ALREADY_LOGGED_IN and CKR_USER_TOO_MANY_TYPES
1220    * are new to v2.01 */
1221    else if (rv == CKR_USER_ANOTHER_ALREADY_LOGGED_IN)//#define CKR_USER_ANOTHER_ALREADY_LOGGED_IN    0x00000104
1222    {
1223        x = "CKR_USER_ANOTHER_ALREADY_LOGGED_IN";
1224    } else if (rv == CKR_USER_TOO_MANY_TYPES)//#define CKR_USER_TOO_MANY_TYPES               0x00000105
1225    {
1226        x = "CKR_USER_TOO_MANY_TYPES";
1227    } else if (rv == CKR_WRAPPED_KEY_INVALID)//#define CKR_WRAPPED_KEY_INVALID               0x00000110
1228    {
1229        x = "CKR_WRAPPED_KEY_INVALID";
1230    } else if (rv == CKR_WRAPPED_KEY_LEN_RANGE)//#define CKR_WRAPPED_KEY_LEN_RANGE             0x00000112
1231    {
1232        x = "CKR_SLOT_CKR_WRAPPED_KEY_LEN_RANGE";
1233    } else if (rv == CKR_WRAPPING_KEY_HANDLE_INVALID)//#define CKR_WRAPPING_KEY_HANDLE_INVALID       0x00000113
1234    {
1235        x = "CKR_WRAPPING_KEY_HANDLE_INVALID";
1236    } else if (rv == CKR_WRAPPING_KEY_SIZE_RANGE)//#define CKR_WRAPPING_KEY_SIZE_RANGE           0x00000114
1237    {
1238        x = "CKR_WRAPPING_KEY_SIZE_RANGE";
1239    } else if (rv == CKR_WRAPPING_KEY_TYPE_INCONSISTENT)//#define CKR_WRAPPING_KEY_TYPE_INCONSISTENT    0x00000115
1240    {
1241        x = "CKR_WRAPPING_KEY_TYPE_INCONSISTENT";
1242    } else if (rv == CKR_RANDOM_SEED_NOT_SUPPORTED)//#define CKR_RANDOM_SEED_NOT_SUPPORTED         0x00000120
1243    {
1244        x = "CKR_RANDOM_SEED_NOT_SUPPORTED";
1245    }
1246    /* These are new to v2.0 */
1247    else if (rv == CKR_RANDOM_NO_RNG)//#define CKR_RANDOM_NO_RNG                     0x00000121
1248    {
1249        x = "CKR_RANDOM_NO_RNG";
1250    }
1251    /* These are new to v2.11 */
1252    else if (rv == CKR_DOMAIN_PARAMS_INVALID)//#define CKR_DOMAIN_PARAMS_INVALID             0x00000130
1253    {
1254        x = "CKR_DOMAIN_PARAMS_INVALID";
1255    }
1256    /* These are new to v2.0 */
1257    else if (rv == CKR_BUFFER_TOO_SMALL)//#define CKR_BUFFER_TOO_SMALL                  0x00000150
1258    {
1259        x = "CKR_BUFFER_TOO_SMALL";
1260    } else if (rv == CKR_SAVED_STATE_INVALID)//#define CKR_SAVED_STATE_INVALID               0x00000160
1261    {
1262        x = "CKR_SAVED_STATE_INVALID";
1263    } else if (rv == CKR_INFORMATION_SENSITIVE)//#define CKR_INFORMATION_SENSITIVE             0x00000170
1264    {
1265        x = "CKR_INFORMATION_SENSITIVE";
1266    } else if (rv == CKR_STATE_UNSAVEABLE)//#define CKR_STATE_UNSAVEABLE                  0x00000180
1267    {
1268        x = "CKR_STATE_UNSAVEABLE";
1269    }
1270    /* These are new to v2.01 */
1271    else if (rv == CKR_CRYPTOKI_NOT_INITIALIZED)//#define CKR_CRYPTOKI_NOT_INITIALIZED          0x00000190
1272    {
1273        x = "CKR_CRYPTOKI_NOT_INITIALIZED";
1274    } else if (rv == CKR_CRYPTOKI_ALREADY_INITIALIZED)    //#define CKR_CRYPTOKI_ALREADY_INITIALIZED      0x00000191
1275    {
1276        x = "CKR_CRYPTOKI_ALREADY_INITIALIZED";
1277    } else if (rv == CKR_MUTEX_BAD)//#define CKR_MUTEX_BAD                         0x000001A0
1278    {
1279        x = "CKR_MUTEX_BAD";
1280    } else if (rv == CKR_MUTEX_NOT_LOCKED)//#define CKR_MUTEX_NOT_LOCKED                  0x000001A1
1281    {
1282        x = "CKR_MUTEX_NOT_LOCKED";
1283
1284    } else if (rv == CKR_VENDOR_DEFINED)//#define CKR_VENDOR_DEFINED                    0x80000000
1285    {
1286        x = "CKR_VENDOR_DEFINED";
1287    } else
1288    {
1289        x = "-1";
1290    }
1291
1292    return x;
1293}
1294
1295
1296QByteArray CryptoToken::toHex(const std::vector<unsigned char> &data)
1297{
1298    return QByteArray((const char*)data.data(), data.size()).toHex();
1299}
1300
1301std::vector<unsigned char> CryptoToken::fromHex(const QString &data)
1302{
1303    QByteArray bin = QByteArray::fromHex(data.toLatin1());
1304    return std::vector<unsigned char>(bin.constData(), bin.constData() + bin.size());
1305}
Note: See TracBrowser for help on using the repository browser.