source: terepaima/signHash/cryptotoken.cpp @ ce57b45

Last change on this file since ce57b45 was ce57b45, checked in by Antonio Araujo <aaraujo@…>, 7 years ago

Avance en función getPrivateKeyLabels
  • Property mode set to 100644
File size: 32.3 KB
Line 
1#include "cryptotoken.h"
2
3#include <assert.h>
4#include <iostream>
5#include <stdexcept>
6
7#define BINARY_SHA1_LENGTH 20
8#define BINARY_SHA224_LENGTH 28
9#define BINARY_SHA256_LENGTH 32
10#define BINARY_SHA384_LENGTH 48
11#define BINARY_SHA512_LENGTH 64
12
13
14CryptoToken::CryptoToken()
15{
16}
17
18
19CryptoToken::~CryptoToken()
20{
21}
22
23
24bool CryptoToken::initializeCriptoki()
25{
26    QString error("");
27    CK_RV rv;
28    rv = C_Initialize(NULL_PTR);
29    if (rv != CKR_OK)
30    {
31        if (rv == CKR_DEVICE_ERROR)
32        {
33            error = returnErrorToQString(rv);
34            qDebug(qPrintable(error));
35            return false;
36        }
37        error = returnErrorToQString(rv);
38        qDebug(qPrintable(error));
39        return false;
40    }
41    else
42    {
43        return true;
44    }
45}
46
47void CryptoToken::finalize() {
48    CK_RV rv;
49    rv = C_Finalize(NULL_PTR);
50    QString error("");
51    if (rv != CKR_OK)
52    {
53        qDebug("** Destruyendo ... ~SmartCard");
54        if (rv == CKR_DEVICE_ERROR)
55        {
56            error = returnErrorToQString(rv);
57            qDebug(qPrintable(error));
58        }
59        error = returnErrorToQString(rv);
60        qDebug(qPrintable(error));
61    }
62}
63
64CK_SESSION_HANDLE CryptoToken::openSession(char * Pin, CK_SLOT_ID & slotID, bool requiredlogin)
65{
66    qDebug("openSession()");
67    QString error("");
68
69    CK_RV rv;
70
71    CK_SLOT_ID SlotList[10];
72    CK_ULONG ulCount = sizeof(SlotList)/sizeof(CK_SLOT_ID);
73
74    CK_SESSION_HANDLE hSession;
75
76    /*
77    ** Find the first slot available that has a token present
78    */
79    rv = C_GetSlotList(TRUE,SlotList,&ulCount);
80    //assert(rv==CKR_OK);
81    //assert(ulCount>0);
82    //if ( (rv != CKR_OK) && (ulCount<=0) )
83    if ( (rv != CKR_OK) || (ulCount<=0) )
84    {
85        error = returnErrorToQString(rv);
86        qDebug(qPrintable("Insertar una tarjeta en el lector. " + error));
87        return CK_INVALID_HANDLE;
88
89    }
90    //slotID = new CK_SLOT_ID() ;
91    slotID = SlotList[0];
92
93    /*
94    ** Open a read/write session with this slot's token
95    */
96    //rv = C_OpenSession(slotID,CKF_SERIAL_SESSION|CKF_RW_SESSION,0,0,&hSession);
97    rv = C_OpenSession(slotID,CKF_SERIAL_SESSION|CKF_RW_SESSION,NULL_PTR,(CK_NOTIFY)NULL_PTR,&hSession);
98
99    //assert(rv==CKR_OK);
100    if (rv != CKR_OK)
101    {
102        error = returnErrorToQString(rv);
103        qDebug(qPrintable("C_OpenSession" + error));
104        return CK_INVALID_HANDLE;
105    }
106
107    /*
108    ** Log in the User to session
109    */
110    if ( requiredlogin ) {
111        rv = C_Login(hSession,CKU_USER, (unsigned char *) Pin,strlen(Pin));
112        //assert(rv==CKR_OK);
113        if (rv != CKR_OK)
114        {
115            error = returnErrorToQString(rv);
116            QString plus("");
117            if ((rv == CKR_PIN_INCORRECT) || (rv == CKR_DATA_LEN_RANGE) || (rv == CKR_ARGUMENTS_BAD))
118                plus = "El PIN introducido es incorrecto!";
119            qDebug(qPrintable("C_login: "  + error + plus));
120            return CK_INVALID_HANDLE;
121        }
122
123    }
124    /*
125    ** Return the session handle and exit
126    */
127    return hSession;
128}
129
130
131
132void CryptoToken::closeSession(CK_SESSION_HANDLE hSession)
133{
134    CK_RV rv;
135    rv = C_CloseSession(hSession);
136    QString error("");
137    if (rv != CKR_OK){
138        qDebug("** Destruyendo ... ~SmartCard");
139        if (rv == CKR_DEVICE_ERROR)
140        {
141            error = returnErrorToQString(rv);
142            qDebug(qPrintable("C_Finalize" + error));
143
144        }
145        error = returnErrorToQString(rv);
146        qDebug(qPrintable("C_Finalize" + error));
147    }
148
149}
150
151
152CK_OBJECT_HANDLE CryptoToken::getPrivateKey(CK_SESSION_HANDLE hSession, CK_SLOT_ID slotID, QString id)
153{
154    QString error("");
155
156    CK_RV rv;
157    CK_OBJECT_HANDLE hObject = CK_INVALID_HANDLE;
158    CK_OBJECT_CLASS objClass = CKO_PRIVATE_KEY;
159    CK_ULONG ulCount = 0;
160
161
162    //CK_BYTE keyid[strlen(id)+1];
163    //strcpy((char *)keyid,id);
164    int idLen = strlen(qPrintable(id))+1;
165
166    CK_UTF8CHAR label[idLen];
167
168    strcpy((char *) label, qPrintable(id));
169    qDebug("SmartCard::getPrivateKey label:");
170    qDebug((char *) label);
171
172    //qDebug("VALOR DE keyid");
173    //qDebug((char *)keyid);
174
175    CK_ATTRIBUTE privateKeyTemplate[] = {
176        { CKA_CLASS, &objClass, sizeof (objClass) },
177        { CKA_LABEL, label, sizeof(label)-1 }
178        //{CKA_ID, keyid, sizeof (keyid)}
179    };
180
181    CK_ULONG ulTemplateCount = sizeof (privateKeyTemplate) / sizeof (privateKeyTemplate[0]);
182
183    /* Pre-condition checks. */
184    assert (hSession != NULL_PTR);
185
186    // comienza la busqueda de clave privada
187    qDebug ("Inicia busqueda de clave privada ... \n");
188
189    rv = C_FindObjectsInit(hSession, privateKeyTemplate, ulTemplateCount);
190    qDebug ("C_FindObjectsInit rv = %x",rv);
191    qDebug ("\n");
192    //assert(rv==CKR_OK);
193    if (rv != CKR_OK)
194    {
195        error = returnErrorToQString(rv);
196        qDebug(qPrintable("C_FindObjectsInit: "+error));
197        return CK_INVALID_HANDLE;
198
199    }
200
201
202    // se realiza la busqueda
203    rv = C_FindObjects(hSession, &hObject, 1, &ulCount);
204    qDebug ("C_FindObjects rv = %x",rv);
205    qDebug ("\n");
206    //assert(rv==CKR_OK);
207
208    qDebug("*-*-*-*-*getPrivateKey VALOR DE ulCount %u: ", ulCount);
209    //if (rv != CKR_OK)
210    if ((rv != CKR_OK) )//|| (ulCount == 0))
211    {
212        if (ulCount == 0)
213            qDebug("ulCount == 0");
214
215        error = returnErrorToQString(rv);
216        qDebug(qPrintable("C_FindObjects: "+error));
217        return CK_INVALID_HANDLE;
218
219    }
220
221    rv = C_FindObjectsFinal(hSession);
222    qDebug ("C_FindObjectsFinal rv = %x",rv);
223    qDebug ("\n");
224    //assert(rv==CKR_OK);
225    if (rv != CKR_OK)
226    {
227        error = returnErrorToQString(rv);
228        qDebug(qPrintable("C_FindObjectsFinal: "+error));
229        return CK_INVALID_HANDLE;
230    }
231
232    if (ulCount == 0)
233    {
234        qDebug (" \nNinguna clave privada encontrada!\n");
235        // cerrar la sesion
236        /*rv = C_CloseAllSessions(slotID);
237        qDebug("C_CloseAllSessions rv = %x", rv);
238        qDebug ("\n");
239        assert(rv==CKR_OK);*/
240        return CK_INVALID_HANDLE;
241        }
242    else
243    {
244        //qDebug (" \nObjeto encontrado (object=0x%04X)\n", hObject);
245        qDebug (" \nClave privada encontrada:  (clave = 0x%4X)\n", hObject);
246        return hObject;
247    }
248}
249
250
251
252bool CryptoToken::signSomeData(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE privateKey, CK_BYTE_PTR someData,
253        CK_ULONG someDataLen, CK_BYTE_PTR sign, CK_ULONG_PTR signLen )
254{
255    CK_RV rv;
256    qDebug (" \nProceso de firma digital de datos con la clave privada que mantiene la tarjeta...\n");
257    qDebug("valor de sign antes de firmar: \n %s\n", sign);
258
259    //CK_ULONG someDataLen, slen;
260    //someDataLen = strlen((char *) someData);
261
262    //CK_ULONG slen;
263    //slen = BUFFERSIZ;
264    //slen = signLen;
265
266    // definicion del algoritmo de firma
267    CK_MECHANISM signMechanism = { CKM_RSA_PKCS /*CKM_SHA1_RSA_PKCS*/, 0 /*NULL_PTR*/, 0};
268
269    rv = C_SignInit(hSession, &signMechanism, privateKey);
270
271    if (rv != CKR_OK) {
272        qDebug("C_SignInit: rv = 0x%.8X\n", rv);
273        rv = C_CloseSession(hSession);
274        qDebug ("C_CloseSession: rv = %x",rv);
275        qDebug ("\n");
276        assert(rv == CKR_OK);
277        rv = C_Finalize(NULL_PTR);
278        qDebug ("C_Finalize: rv = %x",rv);
279        qDebug ("\n");
280        assert(rv == CKR_OK);
281        return false;
282    }
283
284    qDebug("C_SignInit: rv = 0x%.8X\n", rv);
285    qDebug ("\n");
286    assert(rv==CKR_OK);
287
288    rv = C_Sign(hSession, someData, someDataLen, sign, signLen);
289
290    if (rv != CKR_OK) {
291        qDebug("C_Sign: rv = 0x%.8X\n", rv);
292        rv = C_CloseSession(hSession);
293        qDebug ("C_CloseSession: rv = %x",rv);
294        qDebug ("\n");
295        assert(rv == CKR_OK);
296        rv = C_Finalize(NULL_PTR);
297        qDebug ("C_Finalize: rv = %x",rv);
298        qDebug ("\n");
299        assert(rv == CKR_OK);
300        return false;//1;
301    }
302
303    qDebug("Valor de la firma sign: \n%s\n", sign);
304    qDebug("\nValor de signLen: \n%u\n", *signLen);
305
306    qDebug("C_Sign: rv = 0x%.8X\n", rv);
307    qDebug ("\n");
308    assert(rv==CKR_OK);
309
310
311    qDebug("\nMessage was successfully signed with private key!\n");
312    return true;
313
314}
315
316
317std::vector<unsigned char> CryptoToken::signHash(QString hashToSign, QString pin, QString label)
318{
319
320    std::vector<unsigned char> hash = fromHex(hashToSign);
321
322    QString error("");
323    CK_RV rv;
324
325    CK_SESSION_HANDLE hSession = CK_INVALID_HANDLE;
326    CK_SLOT_ID slotID;
327
328    // initialize criptoki
329    rv = C_Initialize(NULL_PTR);
330    if (rv != CKR_OK)
331    {
332        if (rv == CKR_DEVICE_ERROR)
333        {
334            error = returnErrorToQString(rv);
335            qDebug(qPrintable(error));
336            throw std::runtime_error(qPrintable(error));
337        }
338        error = returnErrorToQString(rv);
339        qDebug(qPrintable(error));
340        throw std::runtime_error(qPrintable(error));
341    }
342
343    hSession = openSession((char *) qPrintable(pin), slotID);
344    if (hSession == CK_INVALID_HANDLE)
345    {
346        qDebug("Fallo ptr_SC->openSession");
347        rv = C_Finalize(NULL_PTR);
348        qDebug("C_Finalize: rv = %x",rv);
349        assert(rv == CKR_OK);
350        throw std::runtime_error("Error openning a session");
351    }
352
353    // obtencion de la clave privada para firmar los datos
354    CK_OBJECT_HANDLE privateKey = CK_INVALID_HANDLE;
355
356    //QString label = "New Key aaraujo";
357    privateKey = getPrivateKey(hSession, slotID, label);
358
359    // https://github.com/open-eid/chrome-token-signing/blob/master/host-shared/PKCS11CardManager.h
360
361    if (privateKey == CK_INVALID_HANDLE)
362    {
363        qDebug("Fallo ptr_SC->getPrivateKey");
364        rv = C_CloseSession(hSession);
365        qDebug("C_CloseSession: rv = %x",rv);
366        assert(rv == CKR_OK);
367        rv = C_Finalize(NULL_PTR);
368        qDebug("C_Finalize: rv = %x",rv);
369        assert(rv == CKR_OK);
370        throw std::runtime_error("Error finding private key");
371    }
372
373    CK_MECHANISM mechanism = {CKM_RSA_PKCS, 0, 0};
374
375
376    rv = C_SignInit(hSession, &mechanism, privateKey);
377
378    if (rv != CKR_OK) {
379        qDebug("C_SignInit: rv = 0x%.8X\n", rv);
380        rv = C_CloseSession(hSession);
381        qDebug ("C_CloseSession: rv = %x",rv);
382        qDebug ("\n");
383        assert(rv == CKR_OK);
384        rv = C_Finalize(NULL_PTR);
385        qDebug ("C_Finalize: rv = %x",rv);
386        qDebug ("\n");
387        assert(rv == CKR_OK);
388        throw std::runtime_error("Error C_SignInit");
389    }
390
391    qDebug("C_SignInit: rv = 0x%.8X\n", rv);
392    qDebug ("\n");
393    assert(rv==CKR_OK);
394
395    std::vector<unsigned char> hashWithPadding;
396    switch (hash.size()) {
397        case BINARY_SHA1_LENGTH:
398            hashWithPadding = {0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14};
399            break;
400        case BINARY_SHA224_LENGTH:
401            hashWithPadding = {0x30, 0x2d, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04, 0x1c};
402            break;
403        case BINARY_SHA256_LENGTH:
404            hashWithPadding = {0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20};
405            break;
406        case BINARY_SHA384_LENGTH:
407            hashWithPadding = {0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05, 0x00, 0x04, 0x30};
408            break;
409        case BINARY_SHA512_LENGTH:
410            hashWithPadding = {0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05, 0x00, 0x04, 0x40};
411            break;
412        default:
413            throw std::runtime_error("incorrect digest length, dropping padding");
414    }
415    hashWithPadding.insert(hashWithPadding.end(), hash.begin(), hash.end());
416
417    CK_ULONG signatureLength = 0;
418
419
420    rv = C_Sign(hSession, hashWithPadding.data(), hashWithPadding.size(), nullptr, &signatureLength);
421
422    if (rv != CKR_OK) {
423        qDebug("C_Sign: rv = 0x%.8X\n", rv);
424        rv = C_CloseSession(hSession);
425        qDebug ("C_CloseSession: rv = %x",rv);
426        qDebug ("\n");
427        assert(rv == CKR_OK);
428        rv = C_Finalize(NULL_PTR);
429        qDebug ("C_Finalize: rv = %x",rv);
430        qDebug ("\n");
431        assert(rv == CKR_OK);
432        throw std::runtime_error("Error C_Sign1");
433    }
434
435    std::vector<unsigned char> signature(signatureLength, 0);
436
437    rv = C_Sign(hSession, hashWithPadding.data(), hashWithPadding.size(), signature.data(), &signatureLength);
438
439    if (rv != CKR_OK) {
440        qDebug("C_Sign: rv = 0x%.8X\n", rv);
441        rv = C_CloseSession(hSession);
442        qDebug ("C_CloseSession: rv = %x",rv);
443        qDebug ("\n");
444        assert(rv == CKR_OK);
445        rv = C_Finalize(NULL_PTR);
446        qDebug ("C_Finalize: rv = %x",rv);
447        qDebug ("\n");
448        assert(rv == CKR_OK);
449        throw std::runtime_error("Error C_Sign2");
450    }
451
452
453    qDebug("C_Sign: rv = 0x%.8X\n", rv);
454    qDebug ("\n");
455    assert(rv==CKR_OK);
456
457    closeSession(hSession);
458
459    return signature;
460
461}
462
463/*
464std::vector<CK_OBJECT_HANDLE> CryptoToken::findObject(CK_OBJECT_CLASS objectClass, CK_ULONG max = 2) const {
465    if (!fl) {
466        throw std::runtime_error("PKCS11 is not loaded");
467    }
468    CK_ATTRIBUTE searchAttribute = {CKA_CLASS, &objectClass, sizeof(objectClass)};
469
470
471
472    C(FindObjectsInit, session, &searchAttribute, 1);
473    CK_ULONG objectCount = max;
474    std::vector<CK_OBJECT_HANDLE> objectHandle(objectCount);
475    C(FindObjects, session, objectHandle.data(), objectHandle.size(), &objectCount);
476    C(FindObjectsFinal, session);
477    objectHandle.resize(objectCount);
478    return objectHandle;
479}
480*/
481
482QStringList CryptoToken::getPrivateKeyLabels(QString pin)
483{
484    QStringList list;
485
486    QString error("");
487    CK_RV rv;
488
489    CK_SESSION_HANDLE hSession = CK_INVALID_HANDLE;
490    CK_SLOT_ID slotID;
491
492    // initialize criptoki
493    rv = C_Initialize(NULL_PTR);
494    if (rv != CKR_OK)
495    {
496        if (rv == CKR_DEVICE_ERROR)
497        {
498            error = returnErrorToQString(rv);
499            qDebug(qPrintable(error));
500            throw std::runtime_error(qPrintable(error));
501        }
502        error = returnErrorToQString(rv);
503        qDebug(qPrintable(error));
504        throw std::runtime_error(qPrintable(error));
505    }
506
507    hSession = openSession((char *) qPrintable(pin), slotID);
508    if (hSession == CK_INVALID_HANDLE)
509    {
510        qDebug("Fallo ptr_SC->openSession");
511        rv = C_Finalize(NULL_PTR);
512        qDebug("C_Finalize: rv = %x",rv);
513        assert(rv == CKR_OK);
514        throw std::runtime_error("Error openning a session");
515    }
516
517    CK_OBJECT_CLASS objectClass = CKO_PRIVATE_KEY;
518    //CK_OBJECT_CLASS objectClass = CKO_PUBLIC_KEY;
519    //CK_OBJECT_CLASS objectClass = CKO_CERTIFICATE;
520
521    CK_OBJECT_HANDLE hObject = CK_INVALID_HANDLE;
522    CK_ATTRIBUTE searchAttribute = {CKA_CLASS, &objectClass, sizeof(objectClass)};
523    CK_ULONG ulCount = 0;
524
525    rv = C_FindObjectsInit(hSession, &searchAttribute, 1);
526    qDebug ("C_FindObjectsInit rv = %x",rv);
527    qDebug ("\n");
528    //assert(rv==CKR_OK);
529    if (rv != CKR_OK)
530    {
531        error = returnErrorToQString(rv);
532        qDebug("%s", qPrintable("C_FindObjectsInit: "+error));
533        return list;
534    }
535
536    CK_ULONG objectCount = 3;
537    std::vector<CK_OBJECT_HANDLE> objectHandle(objectCount);
538
539    // se realiza la busqueda
540    //rv = C_FindObjects(hSession, &hObject, 2, &ulCount);
541    rv = C_FindObjects(hSession, objectHandle.data(), objectHandle.size(), &objectCount);
542
543    qDebug ("C_FindObjects rv = %x",rv);
544    qDebug ("\n");
545    //assert(rv==CKR_OK);
546
547    qDebug("*-*-*-*-*getPrivateKeyLabels VALOR DE objectCount %u: ", objectCount);
548    //if (rv != CKR_OK)
549    if ((rv != CKR_OK) )//|| (ulCount == 0))
550    {
551        if (ulCount == 0)
552            qDebug("ulCount == 0");
553
554        error = returnErrorToQString(rv);
555        qDebug(qPrintable("C_FindObjects: "+error));
556        return list;
557
558    }
559
560    rv = C_FindObjectsFinal(hSession);
561    qDebug ("C_FindObjectsFinal rv = %x",rv);
562    qDebug ("\n");
563    //assert(rv==CKR_OK);
564    if (rv != CKR_OK)
565    {
566        error = returnErrorToQString(rv);
567        qDebug(qPrintable("C_FindObjectsFinal: "+error));
568        return list;
569    }
570    objectHandle.resize(objectCount);
571
572    //if (ulCount == 0)
573    if (objectHandle.size() == 0)
574    {
575        qDebug (" \nNinguna clave privada encontrada!\n");
576        // cerrar la sesion
577        /*rv = C_CloseAllSessions(slotID);
578        qDebug("C_CloseAllSessions rv = %x", rv);
579        qDebug ("\n");
580        assert(rv==CKR_OK);*/
581        return list;
582        }
583    else
584    {
585        //qDebug (" \nObjeto encontrado (object=0x%04X)\n", hObject);
586        qDebug("se econtraron %d claves", objectHandle.size());
587        //qDebug (" \nClave privada encontrada:  (clave = 0x%4X)\n", hObject);
588        for (int i=0; i< objectHandle.size(); i++)
589        {
590            qDebug("clave encontrada: 0x%4X", objectHandle[i]);
591        }
592        return list;
593    }
594
595    return list;
596}
597
598// slot para obtener informacion del modulo PKCS11
599QString CryptoToken::getInfoCryptoki()
600{
601    // Generales
602    //if ( !CHECKACCESS_ONE("smartcard information", "execute") ) return;
603    CK_INFO info;
604
605    /* Valor devuelto por las funciones */
606    CK_RV rv;
607
608    QString error("");
609    QString mensaje;
610    mensaje.clear();
611
612    rv = C_Initialize(NULL_PTR);
613
614    //fqDebug(stderr, "C_Initialize: rv = 0x%.8X\n", rv);
615    //cout << "valor decimal de rv: " << rv ;
616
617    //assert(rv == CKR_OK);
618    //mensaje->append("C_Initialize\n");
619    if (rv != CKR_OK)
620    {
621
622        if (rv == CKR_DEVICE_ERROR)
623        {
624            error = returnErrorToQString(rv);
625            qDebug("Probablemente el lector no este conectado");
626            return error;
627        }
628        error = returnErrorToQString(rv);
629        qDebug("valor de x despues de returnError: %s", qPrintable(error));
630        return error;
631    }
632
633
634    rv = C_GetInfo(&info);
635    //fqDebug(stderr, "C_GetInfo: rv = 0x%.8X\n", rv);
636    //cout << "valor decimal de rv: " << rv ;
637
638    if (rv != CKR_OK)
639    {
640        error = returnErrorToQString(rv);
641        return error;
642    }
643    //assert(rv == CKR_OK);
644
645    QString y("Descripcion: ");
646    y.append((const char *) info.libraryDescription);
647    mensaje.append(y);
648
649    QString x("Fabricante: ");
650    x.append((const char *) info.manufacturerID);
651    mensaje.append(x);
652
653    QString cryptokiVersion("Version: ");
654    cryptokiVersion.append(QString::number(info.cryptokiVersion.major));
655    cryptokiVersion.append(".");
656    cryptokiVersion.append(QString::number(info.cryptokiVersion.minor));
657    qDebug(qPrintable(cryptokiVersion));
658    mensaje.append(cryptokiVersion);
659
660    rv = C_Finalize(NULL_PTR);
661    if (rv != CKR_OK)
662    {
663        error = returnErrorToQString(rv);
664        return error;
665    }
666    assert(rv == CKR_OK);
667    //mensaje->append("C_Finalize\n");
668
669    //qDebug("***********************mensaje:");
670    //qDebug(qPrintable(mensaje));
671    return mensaje;
672}
673
674QString CryptoToken::returnErrorToQString(CK_RV rv)
675{
676    QString x("");
677    qDebug("returnErrorToQString");
678    //qDebug("valor de x: ", x);
679    //qDebug("valor de rv: "+ QString::number(rv,16));
680
681    /* CK_RV is a value that identifies the return value of a
682    * Cryptoki function */
683    /* CK_RV was changed from CK_USHORT to CK_ULONG for v2.0 */
684    //typedef CK_ULONG          CK_RV;
685
686    if (rv == CKR_OK) // CKR_OK 0x00000000
687    {
688        x = "CKR_OK";
689    } else if (rv == CKR_CANCEL)  // CKR_CANCEL 0x00000001
690    {
691        x = "CKR_CANCEL";
692    } else if (rv == CKR_HOST_MEMORY) //CKR_HOST_MEMORY 0x00000002
693    {
694        x = "CKR_HOST_MEMORY";
695    } else if (rv == CKR_SLOT_ID_INVALID) //CKR_SLOT_ID_INVALID 0x00000003
696    {
697        x = "CKR_SLOT_ID_INVALID";
698    }
699    /* CKR_FLAGS_INVALID was removed for v2.0 */
700    /* CKR_GENERAL_ERROR and CKR_FUNCTION_FAILED are new for v2.0 */
701    else if (rv == CKR_GENERAL_ERROR)           //CKR_GENERAL_ERROR 0x00000005
702    {
703        x = "CKR_GENERAL_ERROR";
704    } else if (rv == CKR_FUNCTION_FAILED)    //CKR_FUNCTION_FAILED 0x00000006
705    {
706        x = "CKR_FUNCTION_FAILED";
707        return x;
708    }
709    /* CKR_ARGUMENTS_BAD, CKR_NO_EVENT, CKR_NEED_TO_CREATE_THREADS,
710    * and CKR_CANT_LOCK are new for v2.01 */
711    else if (rv == CKR_ARGUMENTS_BAD)       // CKR_ARGUMENTS_BAD 0x00000007
712    {
713        x = "CKR_ARGUMENTS_BAD";
714    } else if (rv == CKR_NO_EVENT) //CKR_NO_EVENT                          0x00000008
715    {
716        x = "CKR_NO_EVENT";
717    } else if (rv == CKR_NEED_TO_CREATE_THREADS) //CKR_NEED_TO_CREATE_THREADS            0x00000009
718    {
719        x = "CKR_NEED_TO_CREATE_THREADS";
720    } else if (rv == CKR_CANT_LOCK) // CKR_CANT_LOCK                         0x0000000A
721    {
722        x = "CKR_CANT_LOCK";
723    } else if (rv == CKR_ATTRIBUTE_READ_ONLY) // CKR_ATTRIBUTE_READ_ONLY               0x00000010
724    {
725        x = "CKR_ATTRIBUTE_READ_ONLY";
726    } else if (rv == CKR_ATTRIBUTE_SENSITIVE) // CKR_ATTRIBUTE_SENSITIVE               0x00000011
727    {
728        x = "CKR_ATTRIBUTE_SENSITIVE";
729    } else if (rv == CKR_ATTRIBUTE_TYPE_INVALID) // CKR_ATTRIBUTE_TYPE_INVALID            0x00000012
730    {
731        x = "CKR_ATTRIBUTE_TYPE_INVALID";
732        return x;
733    } else if (rv == CKR_ATTRIBUTE_VALUE_INVALID)// CKR_ATTRIBUTE_VALUE_INVALID           0x00000013
734    {
735        x = "CKR_ATTRIBUTE_VALUE_INVALID";
736    } else if (rv == CKR_DATA_INVALID)//#define CKR_DATA_INVALID                      0x00000020
737    {
738        x = "CKR_DATA_INVALID";
739    } else if (rv == CKR_DATA_LEN_RANGE) //#define CKR_DATA_LEN_RANGE                    0x00000021
740    {
741        x = "CKR_DATA_LEN_RANGE";
742    } else if (rv == CKR_DEVICE_ERROR) //#define CKR_DEVICE_ERROR                      0x00000030
743    {
744        x = "CKR_DEVICE_ERROR";
745        qDebug("FUCK");
746    } else if (rv == CKR_DEVICE_MEMORY) //#define CKR_DEVICE_MEMORY                     0x00000031
747    {
748        x = "CKR_DEVICE_MEMORY";
749
750    } else if (rv == CKR_DEVICE_REMOVED) //#define CKR_DEVICE_REMOVED                    0x00000032
751    {
752        x = "CKR_DEVICE_REMOVED";
753    } else if (rv == CKR_ENCRYPTED_DATA_INVALID) //#define CKR_ENCRYPTED_DATA_INVALID            0x00000040
754    {
755        x = "CKR_ENCRYPTED_DATA_INVALID";
756    } else if (rv == CKR_ENCRYPTED_DATA_LEN_RANGE) //#define CKR_ENCRYPTED_DATA_LEN_RANGE          0x00000041
757    {
758        x = "CKR_ENCRYPTED_DATA_LEN_RANGE";
759    } else if (rv == CKR_FUNCTION_CANCELED) //#define CKR_FUNCTION_CANCELED                 0x00000050
760    {
761        x = "CKR_FUNCTION_CANCELED";
762    } else if (rv == CKR_FUNCTION_NOT_PARALLEL) //#define CKR_FUNCTION_NOT_PARALLEL             0x00000051
763    {
764        x = "CKR_FUNCTION_NOT_PARALLEL";
765    }
766    /* CKR_FUNCTION_NOT_SUPPORTED is new for v2.0 */
767    else if (rv == CKR_FUNCTION_NOT_SUPPORTED) //#define CKR_FUNCTION_NOT_SUPPORTED            0x00000054
768    {
769        x = "CKR_FUNCTION_NOT_SUPPORTED";
770    } else if (rv == CKR_KEY_HANDLE_INVALID) //#define CKR_KEY_HANDLE_INVALID                0x00000060
771    {
772        x = "CKR_KEY_HANDLE_INVALID";
773    }
774    /* CKR_KEY_SENSITIVE was removed for v2.0 */
775    else if (rv == CKR_KEY_SIZE_RANGE)     //#define CKR_KEY_SIZE_RANGE                    0x00000062
776    {
777        x = "CKR_KEY_SIZE_RANGE";
778    } else if (rv == CKR_KEY_TYPE_INCONSISTENT)//#define CKR_KEY_TYPE_INCONSISTENT             0x00000063
779    {
780        x = "CKR_KEY_TYPE_INCONSISTENT";
781    }
782    /* CKR_KEY_NOT_NEEDED, CKR_KEY_CHANGED, CKR_KEY_NEEDED,
783    * CKR_KEY_INDIGESTIBLE, CKR_KEY_FUNCTION_NOT_PERMITTED,
784    * CKR_KEY_NOT_WRAPPABLE, and CKR_KEY_UNEXTRACTABLE are new for
785    * v2.0 */
786    else if (rv == CKR_KEY_NOT_NEEDED) //#define CKR_KEY_NOT_NEEDED                    0x00000064
787    {
788        x = "CKR_KEY_NOT_NEEDED";
789    } else if (rv == CKR_KEY_CHANGED) //#define CKR_KEY_CHANGED                       0x00000065
790    {
791        x = "CKR_KEY_CHANGED";
792    } else if (rv == CKR_KEY_NEEDED) //#define CKR_KEY_NEEDED                        0x00000066
793    {
794        x = "CKR_KEY_NEEDED";
795    } else if (rv == CKR_KEY_INDIGESTIBLE)//#define CKR_KEY_INDIGESTIBLE                  0x00000067
796    {
797        x = "CKR_KEY_INDIGESTIBLE";
798    } else if (rv == CKR_KEY_FUNCTION_NOT_PERMITTED)//#define CKR_KEY_FUNCTION_NOT_PERMITTED        0x00000068
799    {
800        x = "CKR_KEY_FUNCTION_NOT_PERMITTED";
801    } else if (rv == CKR_KEY_NOT_WRAPPABLE)//#define CKR_KEY_NOT_WRAPPABLE                 0x00000069
802    {
803        x = "CKR_KEY_NOT_WRAPPABLE";
804    } else if (rv == CKR_KEY_UNEXTRACTABLE)//#define CKR_KEY_UNEXTRACTABLE                 0x0000006A
805    {
806        x = "CKR_KEY_UNEXTRACTABLE";
807    } else if (rv == CKR_MECHANISM_INVALID)//#define CKR_MECHANISM_INVALID                 0x00000070
808    {
809        x = "CKR_SLOTCKR_MECHANISM_INVALID";
810    } else if (rv == CKR_MECHANISM_PARAM_INVALID)//#define CKR_MECHANISM_PARAM_INVALID           0x00000071
811    {
812        x = "CKR_MECHANISM_PARAM_INVALID";
813    }
814    /* CKR_OBJECT_CLASS_INCONSISTENT and CKR_OBJECT_CLASS_INVALID
815    * were removed for v2.0 */
816    else if (rv == CKR_OBJECT_HANDLE_INVALID)//#define CKR_OBJECT_HANDLE_INVALID             0x00000082
817    {
818        x = "CKR_OBJECT_HANDLE_INVALID";
819    } else if (rv == CKR_OPERATION_ACTIVE)//#define CKR_OPERATION_ACTIVE                  0x00000090
820    {
821        x = "CKR_OPERATION_ACTIVE";
822    } else if (rv == CKR_OPERATION_NOT_INITIALIZED)//#define CKR_OPERATION_NOT_INITIALIZED         0x00000091
823    {
824        x = "CKR_OPERATION_NOT_INITIALIZED";
825    } else if (rv == CKR_PIN_INCORRECT)//#define CKR_PIN_INCORRECT                     0x000000A0
826    {
827        x = "CKR_PIN_INCORRECT";
828    } else if (rv == CKR_PIN_INVALID)//#define CKR_PIN_INVALID                       0x000000A1
829    {
830        x = "CKR_PIN_INVALID";
831    } else if (rv == CKR_PIN_LEN_RANGE)//#define CKR_PIN_LEN_RANGE                     0x000000A2
832    {
833        x = "CKR_PIN_LEN_RANGE";
834    } /* CKR_PIN_EXPIRED and CKR_PIN_LOCKED are new for v2.0 */
835    else if (rv == CKR_PIN_EXPIRED)//#define CKR_PIN_EXPIRED                       0x000000A3
836    {
837        x = "CKR_PIN_EXPIRED";
838    } else if (rv == CKR_PIN_LOCKED)//#define CKR_PIN_LOCKED                        0x000000A4
839    {
840        x = "CKR_PIN_LOCKED";
841    } else if (rv == CKR_SESSION_CLOSED)//#define CKR_SESSION_CLOSED                    0x000000B0
842    {
843        x = "CKR_SESSION_CLOSED";
844    } else if (rv == CKR_SESSION_COUNT)//#define CKR_SESSION_COUNT                     0x000000B1
845    {
846        x = "CKR_SESSION_COUNT";
847    } else if (rv == CKR_SESSION_HANDLE_INVALID)//#define CKR_SESSION_HANDLE_INVALID            0x000000B3
848    {
849        x = "CKR_SESSION_HANDLE_INVALID";
850    } else if (rv == CKR_SESSION_PARALLEL_NOT_SUPPORTED)//#define CKR_SESSION_PARALLEL_NOT_SUPPORTED    0x000000B4
851    {
852        x = "CKR_SESSION_PARALLEL_NOT_SUPPORTED";
853    } else if (rv == CKR_SESSION_READ_ONLY)//#define CKR_SESSION_READ_ONLY                 0x000000B5
854    {
855        x = "CKR_SESSION_READ_ONLY";
856    } else if (rv == CKR_SESSION_EXISTS)//#define CKR_SESSION_EXISTS                    0x000000B6
857    {
858        x = "CKR_SESSION_EXISTS";
859    }
860    /* CKR_SESSION_READ_ONLY_EXISTS and
861    * CKR_SESSION_READ_WRITE_SO_EXISTS are new for v2.0 */
862
863    else if (rv == CKR_SESSION_READ_ONLY_EXISTS)//#define CKR_SESSION_READ_ONLY_EXISTS          0x000000B7
864    {
865        x = "CKR_SESSION_READ_ONLY_EXISTS";
866    } else if (rv == CKR_SESSION_READ_WRITE_SO_EXISTS)//#define CKR_SESSION_READ_WRITE_SO_EXISTS      0x000000B8
867    {
868        x = "CKR_SESSION_READ_WRITE_SO_EXISTS";
869    } else if (rv == CKR_SIGNATURE_INVALID)//#define CKR_SIGNATURE_INVALID                 0x000000C0
870    {
871        x = "CKR_SIGNATURE_INVALID";
872    } else if (rv == CKR_SIGNATURE_LEN_RANGE)//#define CKR_SIGNATURE_LEN_RANGE               0x000000C1
873    {
874        x = "CKR_SIGNATURE_LEN_RANGE";
875    } else if (rv == CKR_TEMPLATE_INCOMPLETE)//#define CKR_TEMPLATE_INCOMPLETE               0x000000D0
876    {
877        x = "CKR_TEMPLATE_INCOMPLETE";
878    } else if (rv == CKR_TEMPLATE_INCONSISTENT)//#define CKR_TEMPLATE_INCONSISTENT             0x000000D1
879    {
880        x = "CKR_TEMPLATE_INCONSISTENT";
881    } else if (rv == CKR_TOKEN_NOT_PRESENT)//#define CKR_TOKEN_NOT_PRESENT                 0x000000E0
882    {
883        x = "CKR_TOKEN_NOT_PRESENT";
884    } else if (rv == CKR_TOKEN_NOT_RECOGNIZED)//#define CKR_TOKEN_NOT_RECOGNIZED              0x000000E1
885    {
886        x = "CKR_TOKEN_NOT_RECOGNIZED";
887    } else if (rv == CKR_TOKEN_WRITE_PROTECTED)//#define CKR_TOKEN_WRITE_PROTECTED             0x000000E2
888    {
889        x = "CKR_TOKEN_WRITE_PROTECTED";
890    } else if (rv == CKR_UNWRAPPING_KEY_HANDLE_INVALID)//#define CKR_UNWRAPPING_KEY_HANDLE_INVALID     0x000000F0
891    {
892        x = "CKR_UNWRAPPING_KEY_HANDLE_INVALID";
893    } else if (rv == CKR_UNWRAPPING_KEY_SIZE_RANGE)//#define CKR_UNWRAPPING_KEY_SIZE_RANGE         0x000000F1
894    {
895        x = "CKR_UNWRAPPING_KEY_SIZE_RANGE";
896    } else if (rv == CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT)//#define CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT  0x000000F2
897    {
898        x = "CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT";
899    } else if (rv == CKR_USER_ALREADY_LOGGED_IN)//#define CKR_USER_ALREADY_LOGGED_IN            0x00000100
900    {
901        x = "CKR_USER_ALREADY_LOGGED_IN";
902    } else if (rv == CKR_USER_NOT_LOGGED_IN)//#define CKR_USER_NOT_LOGGED_IN                0x00000101
903    {
904        x = "CKR_USER_NOT_LOGGED_IN";
905    } else if (rv == CKR_USER_PIN_NOT_INITIALIZED)//#define CKR_USER_PIN_NOT_INITIALIZED          0x00000102
906    {
907        x = "CKR_USER_PIN_NOT_INITIALIZED";
908    } else if (rv == CKR_USER_TYPE_INVALID)//#define CKR_USER_TYPE_INVALID                 0x00000103
909    {
910        x = "CKR_USER_TYPE_INVALID";
911    }
912    /* CKR_USER_ANOTHER_ALREADY_LOGGED_IN and CKR_USER_TOO_MANY_TYPES
913    * are new to v2.01 */
914    else if (rv == CKR_USER_ANOTHER_ALREADY_LOGGED_IN)//#define CKR_USER_ANOTHER_ALREADY_LOGGED_IN    0x00000104
915    {
916        x = "CKR_USER_ANOTHER_ALREADY_LOGGED_IN";
917    } else if (rv == CKR_USER_TOO_MANY_TYPES)//#define CKR_USER_TOO_MANY_TYPES               0x00000105
918    {
919        x = "CKR_USER_TOO_MANY_TYPES";
920    } else if (rv == CKR_WRAPPED_KEY_INVALID)//#define CKR_WRAPPED_KEY_INVALID               0x00000110
921    {
922        x = "CKR_WRAPPED_KEY_INVALID";
923    } else if (rv == CKR_WRAPPED_KEY_LEN_RANGE)//#define CKR_WRAPPED_KEY_LEN_RANGE             0x00000112
924    {
925        x = "CKR_SLOT_CKR_WRAPPED_KEY_LEN_RANGE";
926    } else if (rv == CKR_WRAPPING_KEY_HANDLE_INVALID)//#define CKR_WRAPPING_KEY_HANDLE_INVALID       0x00000113
927    {
928        x = "CKR_WRAPPING_KEY_HANDLE_INVALID";
929    } else if (rv == CKR_WRAPPING_KEY_SIZE_RANGE)//#define CKR_WRAPPING_KEY_SIZE_RANGE           0x00000114
930    {
931        x = "CKR_WRAPPING_KEY_SIZE_RANGE";
932    } else if (rv == CKR_WRAPPING_KEY_TYPE_INCONSISTENT)//#define CKR_WRAPPING_KEY_TYPE_INCONSISTENT    0x00000115
933    {
934        x = "CKR_WRAPPING_KEY_TYPE_INCONSISTENT";
935    } else if (rv == CKR_RANDOM_SEED_NOT_SUPPORTED)//#define CKR_RANDOM_SEED_NOT_SUPPORTED         0x00000120
936    {
937        x = "CKR_RANDOM_SEED_NOT_SUPPORTED";
938    }
939    /* These are new to v2.0 */
940    else if (rv == CKR_RANDOM_NO_RNG)//#define CKR_RANDOM_NO_RNG                     0x00000121
941    {
942        x = "CKR_RANDOM_NO_RNG";
943    }
944    /* These are new to v2.11 */
945    else if (rv == CKR_DOMAIN_PARAMS_INVALID)//#define CKR_DOMAIN_PARAMS_INVALID             0x00000130
946    {
947        x = "CKR_DOMAIN_PARAMS_INVALID";
948    }
949    /* These are new to v2.0 */
950    else if (rv == CKR_BUFFER_TOO_SMALL)//#define CKR_BUFFER_TOO_SMALL                  0x00000150
951    {
952        x = "CKR_BUFFER_TOO_SMALL";
953    } else if (rv == CKR_SAVED_STATE_INVALID)//#define CKR_SAVED_STATE_INVALID               0x00000160
954    {
955        x = "CKR_SAVED_STATE_INVALID";
956    } else if (rv == CKR_INFORMATION_SENSITIVE)//#define CKR_INFORMATION_SENSITIVE             0x00000170
957    {
958        x = "CKR_INFORMATION_SENSITIVE";
959    } else if (rv == CKR_STATE_UNSAVEABLE)//#define CKR_STATE_UNSAVEABLE                  0x00000180
960    {
961        x = "CKR_STATE_UNSAVEABLE";
962    }
963    /* These are new to v2.01 */
964    else if (rv == CKR_CRYPTOKI_NOT_INITIALIZED)//#define CKR_CRYPTOKI_NOT_INITIALIZED          0x00000190
965    {
966        x = "CKR_CRYPTOKI_NOT_INITIALIZED";
967    } else if (rv == CKR_CRYPTOKI_ALREADY_INITIALIZED)    //#define CKR_CRYPTOKI_ALREADY_INITIALIZED      0x00000191
968    {
969        x = "CKR_CRYPTOKI_ALREADY_INITIALIZED";
970    } else if (rv == CKR_MUTEX_BAD)//#define CKR_MUTEX_BAD                         0x000001A0
971    {
972        x = "CKR_MUTEX_BAD";
973    } else if (rv == CKR_MUTEX_NOT_LOCKED)//#define CKR_MUTEX_NOT_LOCKED                  0x000001A1
974    {
975        x = "CKR_MUTEX_NOT_LOCKED";
976
977    } else if (rv == CKR_VENDOR_DEFINED)//#define CKR_VENDOR_DEFINED                    0x80000000
978    {
979        x = "CKR_VENDOR_DEFINED";
980    } else
981    {
982        x = "-1";
983    }
984
985    return x;
986}
987
988
989QByteArray CryptoToken::toHex(const std::vector<unsigned char> &data)
990{
991    return QByteArray((const char*)data.data(), data.size()).toHex();
992}
993
994std::vector<unsigned char> CryptoToken::fromHex(const QString &data)
995{
996    QByteArray bin = QByteArray::fromHex(data.toLatin1());
997    return std::vector<unsigned char>(bin.constData(), bin.constData() + bin.size());
998}
Note: See TracBrowser for help on using the repository browser.