PKCS#11的部分使用例码，仅供参考

1. //PKCS#11的部分使用例码，仅供参考
2. BOOL _ReadFile(LPCSTR FilePath, BYTE *FileContent, DWORD *FileLength)
3. {
4.     FILE *stream = NULL;
5.     DWORD ContentLen = 0;
6.     DWORD ReadLen = 0;
8.     if ((FilePath == NULL) || (FileLength == NULL))
9.     {
10.         return FALSE;
11.     }
13.     stream = fopen(FilePath, "rb");
14.     if (stream == NULL)
15.     {
16.         return FALSE;
17.     }
19.     fseek(stream, 0, SEEK_END);
20.     ContentLen = ftell(stream);
21.     fseek(stream, 0, SEEK_SET);
23.     if ((FileContent == NULL) || (*FileLength < ContentLen))
24.     {
25.         *FileLength = ContentLen;
26.         fclose(stream);
27.         return FALSE;
28.     }
30.     *FileLength = ContentLen;
31.     ReadLen = fread(FileContent, 1, ContentLen, stream);
32.     fclose(stream);
33.     if (ReadLen != ContentLen)
34.     {
35.         return FALSE;
36.     }
38.     return TRUE;
39. }
41. BOOL OpenSession(CK_SESSION_HANDLE *Session)
42. {
43.     CK_RV Result = CKR_OK;
44.     CK_SESSION_HANDLE TmpSession = 0;
46.     if (Session == NULL)
47.     {
48.         return FALSE;
49.     }
51.     Result = C_Initialize(NULL_PTR);
52.     if (Result != CKR_OK)
53.     {
54.         return FALSE;
55.     }
57.     Result = C_OpenSession(0, CKF_RW_SESSION|CKF_SERIAL_SESSION, NULL, NULL, &TmpSession);
58.     if (Result != CKR_OK)
59.     {
60.         C_Finalize(NULL_PTR);
61.         return FALSE;
62.     }
64.     Result = C_Login(TmpSession, CKU_USER, (CK_UTF8CHAR_PTR)"12345678", 8);
65.     if (Result != CKR_OK)
66.     {
67.         C_CloseSession(TmpSession);
68.         C_Finalize(NULL_PTR);
69.         return FALSE;
70.     }
72.     *Session = TmpSession;
73.     return TRUE;
74. }
76. BOOL CloseSession(CK_SESSION_HANDLE Session)
77. {
78.     C_Logout(Session);
79.     C_CloseSession(Session);
80.     C_Finalize(NULL_PTR);
81.     return TRUE;
82. }
84. BOOL ImportPubKey(CK_SESSION_HANDLE Session)
85. {
86.     BIO *PubFile = NULL;
87.     RSA *RSAPubKey = NULL;
89.     CK_RV Result = CKR_OK;
90.     CK_OBJECT_CLASS objectclass = CKO_PUBLIC_KEY;
91.     CK_KEY_TYPE keytype = CKK_RSA;
92.     CK_BYTE truevalue = TRUE;
93.     CK_BYTE falsevalue = FALSE;
94.     CK_BYTE publab[] = "PubKey";
95.     CK_VOID_PTR RSA_PUB_N = NULL;
96.     CK_VOID_PTR RSA_PUB_E = NULL;
97.     CK_OBJECT_HANDLE PubHandle = 0;
98.     CK_ULONG ObjCount = 0;
100.     PubFile = BIO_new(BIO_s_file());
101.     if (PubFile == NULL)
102.     {
103.         return FALSE;
104.     }
106.     Result = BIO_read_filename(PubFile, "PubKey.pub");
107.     if (Result != 1)
108.     {
109.         BIO_free(PubFile);
110.         return FALSE;
111.     }
113.     RSAPubKey = d2i_RSA_PUBKEY_bio(PubFile, NULL);
114.     if (RSAPubKey == NULL)
115.     {
116.         BIO_free(PubFile);
117.         return FALSE;
118.     }
120.     RSA_PUB_N = (CK_VOID_PTR)malloc(BN_num_bytes(RSAPubKey->n));
121.     Result = BN_bn2bin(RSAPubKey->n, (BYTE*)RSA_PUB_N);
122.     if (Result != BN_num_bytes(RSAPubKey->n))
123.     {
124.         free(RSA_PUB_N);
125.         RSA_free(RSAPubKey);
126.         BIO_free(PubFile);
127.         return FALSE;
128.     }
130.     RSA_PUB_E = (CK_VOID_PTR)malloc(BN_num_bytes(RSAPubKey->e));
131.     Result = BN_bn2bin(RSAPubKey->e, (BYTE*)RSA_PUB_E);
132.     if (Result != BN_num_bytes(RSAPubKey->e))
133.     {
134.         free(RSA_PUB_E);
135.         free(RSA_PUB_N);
136.         RSA_free(RSAPubKey);
137.         BIO_free(PubFile);
138.         return FALSE;
139.     }
141.     CK_ATTRIBUTE PubKeyAttr[] = {
142.         {CKA_CLASS, &objectclass, sizeof(objectclass)},
143.         {CKA_KEY_TYPE, &keytype, sizeof(keytype)},
144.         {CKA_TOKEN, &truevalue, sizeof (truevalue)},
145.         {CKA_LABEL, publab, sizeof(publab)-1},
146.         {CKA_ENCRYPT, &truevalue, sizeof(truevalue)},
147.         {CKA_VERIFY, &truevalue, sizeof(truevalue)},
148.         {CKA_PRIVATE, &falsevalue, sizeof(falsevalue)},
149.         {CKA_MODULUS, RSA_PUB_N, BN_num_bytes(RSAPubKey->n)},
150.         {CKA_PUBLIC_EXPONENT, RSA_PUB_E, BN_num_bytes(RSAPubKey->e)}
151.     };
153.     Result = C_FindObjectsInit(Session, PubKeyAttr, 4);
154.     if (Result != CKR_OK)
155.     {
156.         free(RSA_PUB_E);
157.         free(RSA_PUB_N);
158.         RSA_free(RSAPubKey);
159.         BIO_free(PubFile);
160.         return FALSE;
161.     }
163.     Result = C_FindObjects(Session, &PubHandle, 1, &ObjCount);
164.     if ((Result == CKR_OK) && (ObjCount == 1))
165.     {
166.         C_DestroyObject(Session, PubHandle);
167.     }
169.     Result = C_CreateObject(
170.         Session,
171.         PubKeyAttr,
172.         9,
173.         &PubHandle);
174.     C_FindObjectsFinal(Session);
175.     if (Result != CKR_OK)
176.     {
177.         free(RSA_PUB_E);
178.         free(RSA_PUB_N);
179.         RSA_free(RSAPubKey);
180.         BIO_free(PubFile);
181.         return FALSE;
182.     }
184.     free(RSA_PUB_E);
185.     free(RSA_PUB_N);
186.     RSA_free(RSAPubKey);
187.     BIO_free(PubFile);
188.     return TRUE;
189. }
191. BOOL ImportPriKey(CK_SESSION_HANDLE Session)
192. {
193.     BIO *PriFile = NULL;
194.     RSA *RSAPriKey = NULL;
196.     CK_RV Result = CKR_OK;
197.     CK_OBJECT_CLASS objectclass = CKO_PRIVATE_KEY;
198.     CK_KEY_TYPE keytype = CKK_RSA;
199.     CK_BYTE truevalue = TRUE;
200.     CK_BYTE falsevalue = FALSE;
201.     CK_BYTE prilab[] = "PriKey";
202.     CK_VOID_PTR RSA_PRI_N = NULL;
203.     CK_VOID_PTR RSA_PRI_E = NULL;
204.     CK_VOID_PTR RSA_PRI_P = NULL;
205.     CK_VOID_PTR RSA_PRI_Q = NULL;
206.     CK_VOID_PTR RSA_PRI_D = NULL;
207.     CK_VOID_PTR RSA_PRI_DMP1 = NULL;
208.     CK_VOID_PTR RSA_PRI_DMQ1 = NULL;
209.     CK_VOID_PTR RSA_PRI_IQMP = NULL;
210.     CK_OBJECT_HANDLE PriHandle = 0;
211.     CK_ULONG ObjCount = 0;
213.     PriFile = BIO_new(BIO_s_file());
214.     if (PriFile == NULL)
215.     {
216.         return FALSE;
217.     }
219.     Result = BIO_read_filename(PriFile, "PriKey.pri");
220.     if (Result != 1)
221.     {
222.         BIO_free(PriFile);
223.         return FALSE;
224.     }
226.     RSAPriKey = d2i_RSAPrivateKey_bio(PriFile, NULL);
227.     if (RSAPriKey == NULL)
228.     {
229.         BIO_free(PriFile);
230.         return NULL;
231.     }
233.     RSA_PRI_N = (CK_VOID_PTR)malloc(BN_num_bytes(RSAPriKey->n));
234.     Result = BN_bn2bin(RSAPriKey->n, (BYTE*)RSA_PRI_N);
235.     if (Result != BN_num_bytes(RSAPriKey->n))
236.     {
237.         free(RSA_PRI_N);
238.         RSA_free(RSAPriKey);
239.         BIO_free(PriFile);
240.         return FALSE;
241.     }
243.     RSA_PRI_E = (CK_VOID_PTR)malloc(BN_num_bytes(RSAPriKey->e));
244.     Result = BN_bn2bin(RSAPriKey->e, (BYTE*)RSA_PRI_E);
245.     if (Result != BN_num_bytes(RSAPriKey->e))
246.     {
247.         free(RSA_PRI_E);
248.         free(RSA_PRI_N);
249.         RSA_free(RSAPriKey);
250.         BIO_free(PriFile);
251.         return FALSE;
252.     }
254.     RSA_PRI_P = (CK_VOID_PTR)malloc(BN_num_bytes(RSAPriKey->p));
255.     Result = BN_bn2bin(RSAPriKey->p, (BYTE*)RSA_PRI_P);
256.     if (Result != BN_num_bytes(RSAPriKey->p))
257.     {
258.         free(RSA_PRI_P);
259.         free(RSA_PRI_E);
260.         free(RSA_PRI_N);
261.         RSA_free(RSAPriKey);
262.         BIO_free(PriFile);
263.         return FALSE;
264.     }
266.     RSA_PRI_Q = (CK_VOID_PTR)malloc(BN_num_bytes(RSAPriKey->q));
267.     Result = BN_bn2bin(RSAPriKey->q, (BYTE*)RSA_PRI_Q);
268.     if (Result != BN_num_bytes(RSAPriKey->q))
269.     {
270.         free(RSA_PRI_Q);
271.         free(RSA_PRI_P);
272.         free(RSA_PRI_E);
273.         free(RSA_PRI_N);
274.         RSA_free(RSAPriKey);
275.         BIO_free(PriFile);
276.         return FALSE;
277.     }
279.     RSA_PRI_D = (CK_VOID_PTR)malloc(BN_num_bytes(RSAPriKey->d));
280.     Result = BN_bn2bin(RSAPriKey->d, (BYTE*)RSA_PRI_D);
281.     if (Result != BN_num_bytes(RSAPriKey->d))
282.     {
283.         free(RSA_PRI_D);
284.         free(RSA_PRI_Q);
285.         free(RSA_PRI_P);
286.         free(RSA_PRI_E);
287.         free(RSA_PRI_N);
288.         RSA_free(RSAPriKey);
289.         BIO_free(PriFile);
290.         return FALSE;
291.     }
293.     RSA_PRI_DMP1 = (CK_VOID_PTR)malloc(BN_num_bytes(RSAPriKey->dmp1));
294.     Result = BN_bn2bin(RSAPriKey->dmp1, (BYTE*)RSA_PRI_DMP1);
295.     if (Result != BN_num_bytes(RSAPriKey->dmp1))
296.     {
297.         free(RSA_PRI_DMP1);
298.         free(RSA_PRI_D);
299.         free(RSA_PRI_Q);
300.         free(RSA_PRI_P);
301.         free(RSA_PRI_E);
302.         free(RSA_PRI_N);
303.         RSA_free(RSAPriKey);
304.         BIO_free(PriFile);
305.         return FALSE;
306.     }
308.     RSA_PRI_DMQ1 = (CK_VOID_PTR)malloc(BN_num_bytes(RSAPriKey->dmq1));
309.     Result = BN_bn2bin(RSAPriKey->dmq1, (BYTE*)RSA_PRI_DMQ1);
310.     if (Result != BN_num_bytes(RSAPriKey->dmq1))
311.     {
312.         free(RSA_PRI_DMQ1);
313.         free(RSA_PRI_DMP1);
314.         free(RSA_PRI_D);
315.         free(RSA_PRI_Q);
316.         free(RSA_PRI_P);
317.         free(RSA_PRI_E);
318.         free(RSA_PRI_N);
319.         RSA_free(RSAPriKey);
320.         BIO_free(PriFile);
321.         return FALSE;
322.     }
324.     RSA_PRI_IQMP = (CK_VOID_PTR)malloc(BN_num_bytes(RSAPriKey->iqmp));
325.     Result = BN_bn2bin(RSAPriKey->iqmp, (BYTE*)RSA_PRI_IQMP);
326.     if (Result != BN_num_bytes(RSAPriKey->iqmp))
327.     {
328.         free(RSA_PRI_IQMP);
329.         free(RSA_PRI_DMQ1);
330.         free(RSA_PRI_DMP1);
331.         free(RSA_PRI_D);
332.         free(RSA_PRI_Q);
333.         free(RSA_PRI_P);
334.         free(RSA_PRI_E);
335.         free(RSA_PRI_N);
336.         RSA_free(RSAPriKey);
337.         BIO_free(PriFile);
338.         return FALSE;
339.     }
341.     CK_ATTRIBUTE PriKeyAttr[] = {
342.         {CKA_CLASS, &objectclass, sizeof(objectclass)},
343.         {CKA_KEY_TYPE, &keytype, sizeof(keytype)},
344.         {CKA_TOKEN, &truevalue, sizeof (truevalue)},
345.         {CKA_LABEL, prilab, sizeof(prilab)-1},
346.         {CKA_DECRYPT, &truevalue, sizeof(truevalue)},
347.         {CKA_SIGN, &truevalue, sizeof(truevalue)},
348.         {CKA_PRIVATE, &truevalue, sizeof(truevalue)},
349.         {CKA_MODULUS, RSA_PRI_N, BN_num_bytes(RSAPriKey->n)},
350.         {CKA_PUBLIC_EXPONENT, RSA_PRI_E, BN_num_bytes(RSAPriKey->e)},
351.         {CKA_PRIME_1, RSA_PRI_P, BN_num_bytes(RSAPriKey->p)},
352.         {CKA_PRIME_2, RSA_PRI_Q, BN_num_bytes(RSAPriKey->q)},
353.         {CKA_PRIVATE_EXPONENT, RSA_PRI_D, BN_num_bytes(RSAPriKey->d)},
354.         {CKA_EXPONENT_1, RSA_PRI_DMP1, BN_num_bytes(RSAPriKey->dmp1)},
355.         {CKA_EXPONENT_2, RSA_PRI_DMQ1, BN_num_bytes(RSAPriKey->dmq1)},
356.         {CKA_COEFFICIENT, RSA_PRI_IQMP, BN_num_bytes(RSAPriKey->iqmp)}
357.     };
359.     Result = C_FindObjectsInit(Session, PriKeyAttr, 4);
360.     if (Result != CKR_OK)
361.     {
362.         free(RSA_PRI_IQMP);
363.         free(RSA_PRI_DMQ1);
364.         free(RSA_PRI_DMP1);
365.         free(RSA_PRI_D);
366.         free(RSA_PRI_Q);
367.         free(RSA_PRI_P);
368.         free(RSA_PRI_E);
369.         free(RSA_PRI_N);
370.         RSA_free(RSAPriKey);
371.         BIO_free(PriFile);
372.         return FALSE;
373.     }
375.     Result = C_FindObjects(Session, &PriHandle, 1, &ObjCount);
376.     if ((Result == CKR_OK) && (ObjCount == 1))
377.     {
378.         C_DestroyObject(Session, PriHandle);
379.     }
381.     Result = C_CreateObject(
382.         Session,
383.         PriKeyAttr,
384.         15,
385.         &PriHandle);
386.     C_FindObjectsFinal(Session);
387.     if (Result != CKR_OK)
388.     {
389.         free(RSA_PRI_IQMP);
390.         free(RSA_PRI_DMQ1);
391.         free(RSA_PRI_DMP1);
392.         free(RSA_PRI_D);
393.         free(RSA_PRI_Q);
394.         free(RSA_PRI_P);
395.         free(RSA_PRI_E);
396.         free(RSA_PRI_N);
397.         RSA_free(RSAPriKey);
398.         BIO_free(PriFile);
399.         return FALSE;
400.     }
402.     free(RSA_PRI_IQMP);
403.     free(RSA_PRI_DMQ1);
404.     free(RSA_PRI_DMP1);
405.     free(RSA_PRI_D);
406.     free(RSA_PRI_Q);
407.     free(RSA_PRI_P);
408.     free(RSA_PRI_E);
409.     free(RSA_PRI_N);
410.     RSA_free(RSAPriKey);
411.     BIO_free(PriFile);
412.     return TRUE;
413. }
415. BOOL ImportData(CK_SESSION_HANDLE Session)
416. {
417.     CK_RV Result = CKR_OK;
418.     CK_OBJECT_CLASS objectclass = CKO_DATA;
419.     CK_BYTE truevalue = TRUE;
420.     CK_BYTE falsevalue = FALSE;
421.     CK_BYTE datalab[] = "Data";
422.     CK_BYTE databuf[1024] = {0};
423.     CK_ULONG databuflen = 1024;
424.     CK_OBJECT_HANDLE DataHandle = 0;
425.     CK_ULONG ObjCount = 0;
427.     _ReadFile("data.txt", databuf, &databuflen);
429.     CK_ATTRIBUTE DataAttr[] = {
430.         {CKA_CLASS, &objectclass, sizeof(objectclass)},
431.         {CKA_TOKEN, &truevalue, sizeof (truevalue)},
432.         {CKA_LABEL, datalab, sizeof(datalab)-1},
433.         {CKA_VALUE, databuf, databuflen}
434.     };
436.     Result = C_FindObjectsInit(Session, DataAttr, 3);
437.     if (Result != CKR_OK)
438.     {
439.         return FALSE;
440.     }
442.     Result = C_FindObjects(Session, &DataHandle, 1, &ObjCount);
443.     if ((Result == CKR_OK) && (ObjCount == 1))
444.     {
445.         C_DestroyObject(Session, DataHandle);
446.     }
448.     Result = C_CreateObject(
449.         Session,
450.         DataAttr,
451.         4,
452.         &DataHandle);
453.     C_FindObjectsFinal(Session);
454.     if (Result != CKR_OK)
455.     {
456.         return FALSE;
457.     }
459.     return TRUE;
460. }
462. BOOL P11GernateRSA(CK_SESSION_HANDLE Session)
463. {
464.     CK_RV Result = CKR_OK;
465.     CK_OBJECT_CLASS pubkeyclass = CKO_PUBLIC_KEY;
466.     CK_OBJECT_CLASS prikeyclass = CKO_PRIVATE_KEY;
467.     CK_BYTE truevalue = TRUE;
468.     CK_BYTE falsevalue = FALSE;
469.     CK_BYTE pubkeylab[] = "P11PubKey";
470.     CK_BYTE prikeylab[] = "P11PriKey";
471.     CK_ULONG ModBit = 1024;
472.     CK_OBJECT_HANDLE PubHandle = 0;
473.     CK_OBJECT_HANDLE PriHandle = 0;
474.     CK_ULONG ObjCount = 0;
476.     CK_ATTRIBUTE PubKeyAttr[] = {
477.         {CKA_CLASS, &pubkeyclass, sizeof(pubkeyclass)},
478.         {CKA_TOKEN, &truevalue, sizeof (truevalue)},
479.         {CKA_LABEL, pubkeylab, sizeof(pubkeylab)-1},
480.         {CKA_ENCRYPT, &truevalue, sizeof(truevalue)},
481.         {CKA_VERIFY, &truevalue, sizeof(truevalue)},
482.         {CKA_PRIVATE, &falsevalue, sizeof (falsevalue)},
483.         {CKA_MODULUS_BITS, &ModBit, sizeof(ModBit)}
484.     };
486.     CK_ATTRIBUTE PriKeyAttr[] = {
487.         {CKA_CLASS, &prikeyclass, sizeof(prikeyclass)},
488.         {CKA_TOKEN, &truevalue, sizeof (truevalue)},
489.         {CKA_LABEL, prikeylab, sizeof(prikeylab)-1},
490.         {CKA_DECRYPT, &truevalue, sizeof(truevalue)},
491.         {CKA_SIGN, &truevalue, sizeof(truevalue)},
492.         {CKA_PRIVATE, &truevalue, sizeof(truevalue)},
493.         {CKA_MODULUS_BITS, &ModBit, sizeof(ModBit)}
494.     };
496.     CK_MECHANISM mechanism = {CKM_RSA_PKCS_KEY_PAIR_GEN, NULL_PTR, 0};
499.     Result = C_FindObjectsInit(Session, PubKeyAttr, 3);
500.     if (Result != CKR_OK)
501.     {
502.         return FALSE;
503.     }
505.     Result = C_FindObjects(Session, &PubHandle, 1, &ObjCount);
506.     if (Result == CKR_OK)
507.     {
508.         C_DestroyObject(Session, PubHandle);
509.     }
511.     C_FindObjectsFinal(Session);
513.     Result = C_FindObjectsInit(Session, PriKeyAttr, 3);
514.     if (Result != CKR_OK)
515.     {
516.         return FALSE;
517.     }
519.     Result = C_FindObjects(Session, &PriHandle, 1, &ObjCount);
520.     if (Result == CKR_OK)
521.     {
522.         C_DestroyObject(Session, PriHandle);
523.     }
525.     C_FindObjectsFinal(Session);
527.     Result = C_GenerateKeyPair(
528.         Session,
529.         &mechanism,
530.         PubKeyAttr,
531.         7,
532.         PriKeyAttr,
533.         7,
534.         &PubHandle,
535.         &PriHandle);
536.     if (Result != CKR_OK)
537.     {
538.         return FALSE;
539.     }
541.     return TRUE;
542. }
544. BOOL TestReadData(CK_SESSION_HANDLE Session)
545. {
546.     CK_RV Result = CKR_OK;
547.     CK_OBJECT_CLASS objectclass = CKO_DATA;
548.     CK_BYTE truevalue = TRUE;
549.     CK_BYTE falsevalue = FALSE;
550.     CK_BYTE datalab[] = "Data";
551.     CK_BYTE databuf[1024] = {0};
552.     CK_ULONG databuflen = 1024;
553.     CK_OBJECT_HANDLE DataHandle = 0;
554.     CK_ULONG ObjCount = 0;
556.     CK_ATTRIBUTE DataAttr[] = {
557.         {CKA_CLASS, &objectclass, sizeof(objectclass)},
558.         {CKA_TOKEN, &truevalue, sizeof (truevalue)},
559.         {CKA_LABEL, datalab, sizeof(datalab)-1},
560.         {CKA_VALUE, databuf, databuflen}
561.     };
563.     Result = C_FindObjectsInit(Session, DataAttr, 3);
564.     if (Result != CKR_OK)
565.     {
566.         return FALSE;
567.     }
569.     Result = C_FindObjects(Session, &DataHandle, 1, &ObjCount);
570.     if ((Result != CKR_OK) || (ObjCount == 0))
571.     {
572.         C_FindObjectsFinal(Session);
573.         return FALSE;
574.     }
576.     Result = C_GetAttributeValue(Session, DataHandle, DataAttr, 4);
577.     C_FindObjectsFinal(Session);
578.     if (Result != CKR_OK)
579.     {
580.         return FALSE;
581.     }
583.     printf("data:/n%s/n", DataAttr[3].pValue);
584.     return TRUE;
585. }
587. BOOL TestWriteData(CK_SESSION_HANDLE Session)
588. {
589.     CK_RV Result = CKR_OK;
590.     CK_OBJECT_CLASS objectclass = CKO_DATA;
591.     CK_BYTE truevalue = TRUE;
592.     CK_BYTE falsevalue = FALSE;
593.     CK_BYTE datalab[] = "Data";
594.     CK_BYTE databuf[] = "hello china";
595.     CK_ULONG databuflen = sizeof(databuf)-1;
596.     CK_OBJECT_HANDLE DataHandle = 0;
597.     CK_ULONG ObjCount = 0;
599.     CK_ATTRIBUTE DataAttr[] = {
600.         {CKA_CLASS, &objectclass, sizeof(objectclass)},
601.         {CKA_TOKEN, &truevalue, sizeof (truevalue)},
602.         {CKA_LABEL, datalab, sizeof(datalab)-1},
603.         {CKA_VALUE, databuf, databuflen}
604.     };
606.     Result = C_FindObjectsInit(Session, DataAttr, 3);
607.     if (Result != CKR_OK)
608.     {
609.         return FALSE;
610.     }
612.     Result = C_FindObjects(Session, &DataHandle, 1, &ObjCount);
613.     if ((Result != CKR_OK) || (ObjCount == 0))
614.     {
615.         C_FindObjectsFinal(Session);
616.         return FALSE;
617.     }
619.     Result = C_SetAttributeValue(Session, DataHandle, DataAttr, 4);
620.     C_FindObjectsFinal(Session);
621.     if (Result != CKR_OK)
622.     {
623.         return FALSE;
624.     }
626.     return TRUE;
627. }
629. BOOL TestP11RSAEncrypt(CK_SESSION_HANDLE Session, CK_BYTE_PTR DeBuf, CK_ULONG DeBufLen, CK_BYTE_PTR EnBuf, CK_ULONG_PTR EnBufLen)
630. {
631.     CK_RV Result = CKR_OK;
632.     CK_OBJECT_CLASS objectclass = CKO_PUBLIC_KEY;
633.     CK_KEY_TYPE keytype = CKK_RSA;
634.     CK_BYTE truevalue = TRUE;
635.     CK_BYTE falsevalue = FALSE;
636.     CK_BYTE publab[] = "PubKey";
637.     CK_OBJECT_HANDLE PubHandle = 0;
638.     CK_ULONG ObjCount = 0;
640.     CK_ATTRIBUTE PubKeyAttr[] = {
641.         {CKA_CLASS, &objectclass, sizeof(objectclass)},
642.         {CKA_KEY_TYPE, &keytype, sizeof(keytype)},
643.         {CKA_TOKEN, &truevalue, sizeof (truevalue)},
644.         {CKA_LABEL, publab, sizeof(publab)-1},
645.     };
647.     CK_MECHANISM mechanism = {CKM_RSA_PKCS, NULL_PTR, 0};
649.     Result = C_FindObjectsInit(Session, PubKeyAttr, 4);
650.     if (Result != CKR_OK)
651.     {
652.         return FALSE;
653.     }
655.     Result = C_FindObjects(Session, &PubHandle, 1, &ObjCount);
656.     C_FindObjectsFinal(Session);
657.     if ((Result != CKR_OK) || (ObjCount == 0))
658.     {
659.         return FALSE;
660.     }
662.     Result = C_EncryptInit(Session, &mechanism, PubHandle);
663.     if (Result != CKR_OK)
664.     {
665.         return FALSE;
666.     }
668.     Result = C_Encrypt(Session, DeBuf, DeBufLen, EnBuf, EnBufLen);
669.     if (Result != CKR_OK)
670.     {
671.         return FALSE;
672.     }
674.     return TRUE;
675. }
677. BOOL TestP11RSADecrypt(CK_SESSION_HANDLE Session, CK_BYTE_PTR EnBuf, CK_ULONG EnBufLen, CK_BYTE_PTR DeBuf, CK_ULONG_PTR DeBufLen)
678. {
679.     CK_RV Result = CKR_OK;
680.     CK_OBJECT_CLASS objectclass = CKO_PRIVATE_KEY;
681.     CK_KEY_TYPE keytype = CKK_RSA;
682.     CK_BYTE truevalue = TRUE;
683.     CK_BYTE falsevalue = FALSE;
684.     CK_BYTE prilab[] = "PriKey";
685.     CK_OBJECT_HANDLE PriHandle = 0;
686.     CK_ULONG ObjCount = 0;
688.     CK_ATTRIBUTE PriKeyAttr[] = {
689.         {CKA_CLASS, &objectclass, sizeof(objectclass)},
690.         {CKA_KEY_TYPE, &keytype, sizeof(keytype)},
691.         {CKA_TOKEN, &truevalue, sizeof (truevalue)},
692.         {CKA_LABEL, prilab, sizeof(prilab)-1}
693.     };
695.     CK_MECHANISM mechanism = {CKM_RSA_PKCS, NULL_PTR, 0};
697.     Result = C_FindObjectsInit(Session, PriKeyAttr, 4);
698.     if (Result != CKR_OK)
699.     {
700.         return FALSE;
701.     }
703.     Result = C_FindObjects(Session, &PriHandle, 1, &ObjCount);
704.     C_FindObjectsFinal(Session);
705.     if ((Result != CKR_OK) || (ObjCount == 0))
706.     {
707.         return FALSE;
708.     }
710.     Result = C_DecryptInit(Session, &mechanism, PriHandle);
711.     if (Result != CKR_OK)
712.     {
713.         return FALSE;
714.     }
716.     Result = C_Decrypt(Session, EnBuf, EnBufLen, DeBuf, DeBufLen);
717.     if (Result != CKR_OK)
718.     {
719.         return FALSE;
720.     }
722.     return TRUE;
723. }
725. BOOL TestOpenSSLRSAEncrypt(CK_BYTE_PTR DeBuf, CK_ULONG DeBufLen, CK_BYTE_PTR EnBuf, CK_ULONG_PTR EnBufLen)
726. {
727.     BIO *PubFile = NULL;
728.     RSA *RSAPubKey = NULL;
729.     int Padding = RSA_PKCS1_PADDING;
731.     CK_RV Result = CKR_OK;
733.     PubFile = BIO_new(BIO_s_file());
734.     if (PubFile == NULL)
735.     {
736.         return FALSE;
737.     }
739.     Result = BIO_read_filename(PubFile, "PubKey.pub");
740.     if (Result != 1)
741.     {
742.         BIO_free(PubFile);
743.         return FALSE;
744.     }
746.     RSAPubKey = d2i_RSA_PUBKEY_bio(PubFile, NULL);
747.     if (RSAPubKey == NULL)
748.     {
749.         BIO_free(PubFile);
750.         return FALSE;
751.     }
753.     *EnBufLen = RSA_public_encrypt(DeBufLen, DeBuf, EnBuf, RSAPubKey, Padding);
754.     if (*EnBufLen <= 0)
755.     {
756.         RSA_free(RSAPubKey);
757.         BIO_free(PubFile);
758.         return FALSE;
759.     }
761.     RSA_free(RSAPubKey);
762.     BIO_free(PubFile);
763.     return TRUE;
764. }
766. BOOL TestOpenSSLRSADecrypt(CK_BYTE_PTR EnBuf, CK_ULONG EnBufLen, CK_BYTE_PTR DeBuf, CK_ULONG_PTR DeBufLen)
767. {
768.     BIO *PriFile = NULL;
769.     RSA *RSAPriKey = NULL;
770.     int Padding = RSA_PKCS1_PADDING;
772.     CK_RV Result = CKR_OK;
774.     PriFile = BIO_new(BIO_s_file());
775.     if (PriFile == NULL)
776.     {
777.         return FALSE;
778.     }
780.     Result = BIO_read_filename(PriFile, "PriKey.pri");
781.     if (Result != 1)
782.     {
783.         BIO_free(PriFile);
784.         return FALSE;
785.     }
787.     RSAPriKey = d2i_RSAPrivateKey_bio(PriFile, NULL);
788.     if (RSAPriKey == NULL)
789.     {
790.         BIO_free(PriFile);
791.         return FALSE;
792.     }
794.     *DeBufLen = RSA_private_decrypt(EnBufLen, EnBuf, DeBuf, RSAPriKey, Padding);
795.     if (*DeBufLen <= 0)
796.     {
797.         RSA_free(RSAPriKey);
798.         BIO_free(PriFile);
799.         return FALSE;
800.     }
802.     RSA_free(RSAPriKey);
803.     BIO_free(PriFile);
804.     return TRUE;
805. }
807. BOOL TestP11RSASign(CK_SESSION_HANDLE Session, CK_BYTE_PTR DeBuf, CK_ULONG DeBufLen, CK_BYTE_PTR EnBuf, CK_ULONG_PTR EnBufLen)
808. {
809.     CK_RV Result = CKR_OK;
810.     CK_OBJECT_CLASS objectclass = CKO_PRIVATE_KEY;
811.     CK_KEY_TYPE keytype = CKK_RSA;
812.     CK_BYTE truevalue = TRUE;
813.     CK_BYTE falsevalue = FALSE;
814.     CK_BYTE prilab[] = "PriKey";
815.     CK_OBJECT_HANDLE PriHandle = 0;
816.     CK_ULONG ObjCount = 0;
818.     CK_ATTRIBUTE PriKeyAttr[] = {
819.         {CKA_CLASS, &objectclass, sizeof(objectclass)},
820.         {CKA_KEY_TYPE, &keytype, sizeof(keytype)},
821.         {CKA_TOKEN, &truevalue, sizeof (truevalue)},
822.         {CKA_LABEL, prilab, sizeof(prilab)-1}
823.     };
825.     CK_MECHANISM mechanism = {CKM_RSA_PKCS, NULL_PTR, 0};
827.     Result = C_FindObjectsInit(Session, PriKeyAttr, 4);
828.     if (Result != CKR_OK)
829.     {
830.         return FALSE;
831.     }
833.     Result = C_FindObjects(Session, &PriHandle, 1, &ObjCount);
834.     C_FindObjectsFinal(Session);
835.     if ((Result != CKR_OK) || (ObjCount == 0))
836.     {
837.         return FALSE;
838.     }
840.     Result = C_SignInit(Session, &mechanism, PriHandle);
841.     if (Result != CKR_OK)
842.     {
843.         return FALSE;
844.     }
846.     Result = C_Sign(Session, DeBuf, DeBufLen, EnBuf, EnBufLen);
847.     if (Result != CKR_OK)
848.     {
849.         return FALSE;
850.     }
852.     return TRUE;
853. }
855. BOOL TestP11RSAVerify(CK_SESSION_HANDLE Session, CK_BYTE_PTR EnBuf, CK_ULONG EnBufLen, CK_BYTE_PTR DeBuf, CK_ULONG DeBufLen)
856. {
857.     CK_RV Result = CKR_OK;
858.     CK_OBJECT_CLASS objectclass = CKO_PUBLIC_KEY;
859.     CK_KEY_TYPE keytype = CKK_RSA;
860.     CK_BYTE truevalue = TRUE;
861.     CK_BYTE falsevalue = FALSE;
862.     CK_BYTE publab[] = "PubKey";
863.     CK_OBJECT_HANDLE PubHandle = 0;
864.     CK_ULONG ObjCount = 0;
866.     CK_ATTRIBUTE PubKeyAttr[] = {
867.         {CKA_CLASS, &objectclass, sizeof(objectclass)},
868.         {CKA_KEY_TYPE, &keytype, sizeof(keytype)},
869.         {CKA_TOKEN, &truevalue, sizeof (truevalue)},
870.         {CKA_LABEL, publab, sizeof(publab)-1},
871.     };
873.     CK_MECHANISM mechanism = {CKM_RSA_PKCS, NULL_PTR, 0};
875.     Result = C_FindObjectsInit(Session, PubKeyAttr, 4);
876.     if (Result != CKR_OK)
877.     {
878.         return FALSE;
879.     }
881.     Result = C_FindObjects(Session, &PubHandle, 1, &ObjCount);
882.     C_FindObjectsFinal(Session);
883.     if ((Result != CKR_OK) || (ObjCount == 0))
884.     {
885.         return FALSE;
886.     }
888.     Result = C_VerifyInit(Session, &mechanism, PubHandle);
889.     if (Result != CKR_OK)
890.     {
891.         return FALSE;
892.     }
894.     Result = C_Verify(Session, DeBuf, DeBufLen, EnBuf, EnBufLen);
895.     if (Result != CKR_OK)
896.     {
897.         return FALSE;
898.     }
900.     return TRUE;
901. }
903. BOOL TestOpenSSLRSASign(CK_BYTE_PTR DeBuf, CK_ULONG DeBufLen, CK_BYTE_PTR EnBuf, CK_ULONG_PTR EnBufLen)
904. {
905.     BIO *PriFile = NULL;
906.     RSA *RSAPriKey = NULL;
907.     int Padding = RSA_PKCS1_PADDING;
909.     CK_RV Result = CKR_OK;
911.     PriFile = BIO_new(BIO_s_file());
912.     if (PriFile == NULL)
913.     {
914.         return FALSE;
915.     }
917.     Result = BIO_read_filename(PriFile, "PriKey.pri");
918.     if (Result != 1)
919.     {
920.         BIO_free(PriFile);
921.         return FALSE;
922.     }
924.     RSAPriKey = d2i_RSAPrivateKey_bio(PriFile, NULL);
925.     if (RSAPriKey == NULL)
926.     {
927.         BIO_free(PriFile);
928.         return FALSE;
929.     }
931.     Result = RSA_sign(NID_md5_sha1, DeBuf, DeBufLen, EnBuf, (unsigned int*)EnBufLen, RSAPriKey);
932.     if (Result != 1)
933.     {
934.         RSA_free(RSAPriKey);
935.         BIO_free(PriFile);
936.         return FALSE;
937.     }
939.     RSA_free(RSAPriKey);
940.     BIO_free(PriFile);
941.     return TRUE;
942. }
944. BOOL TestOpenSSLRSAVerify(CK_BYTE_PTR EnBuf, CK_ULONG EnBufLen, CK_BYTE_PTR DeBuf, CK_ULONG DeBufLen)
945. {
946.     BIO *PubFile = NULL;
947.     RSA *RSAPubKey = NULL;
948.     int Padding = RSA_PKCS1_PADDING;
950.     CK_RV Result = CKR_OK;
952.     PubFile = BIO_new(BIO_s_file());
953.     if (PubFile == NULL)
954.     {
955.         return FALSE;
956.     }
958.     Result = BIO_read_filename(PubFile, "PubKey.pub");
959.     if (Result != 1)
960.     {
961.         BIO_free(PubFile);
962.         return FALSE;
963.     }
965.     RSAPubKey = d2i_RSA_PUBKEY_bio(PubFile, NULL);
966.     if (RSAPubKey == NULL)
967.     {
968.         BIO_free(PubFile);
969.         return FALSE;
970.     }
972.     Result = RSA_verify(NID_md5_sha1, DeBuf, DeBufLen, EnBuf, EnBufLen, RSAPubKey);
973.     if (Result != 1)
974.     {
975.         RSA_free(RSAPubKey);
976.         BIO_free(PubFile);
977.         return FALSE;
978.     }
980.     RSA_free(RSAPubKey);
981.     BIO_free(PubFile);
982.     return TRUE;
983. }
985. RSA* GetRSAPubKey(CK_SESSION_HANDLE Session)
986. {
987.     CK_RV Result = CKR_OK;
988.     RSA *PubKey = NULL;
989.     CK_OBJECT_CLASS objectclass = CKO_PUBLIC_KEY;
990.     CK_KEY_TYPE keytype = CKK_RSA;
991.     CK_BYTE truevalue = TRUE;
992.     CK_BYTE falsevalue = FALSE;
993.     CK_BYTE publab[] = "PubKey";
994.     CK_OBJECT_HANDLE PubHandle = 0;
995.     CK_ULONG ObjCount = 0;
996.     CK_BYTE RSA_PUB_N[1024] = {0};
997.     CK_ULONG RSA_PUB_N_LEN = 1024;
998.     CK_BYTE RSA_PUB_E[1024] = {0};
999.     CK_ULONG RSA_PUB_E_LEN = 1024;
1001.     CK_ATTRIBUTE PubKeyAttr[] = {
1002.         {CKA_CLASS, &objectclass, sizeof(objectclass)},
1003.         {CKA_KEY_TYPE, &keytype, sizeof(keytype)},
1004.         {CKA_TOKEN, &truevalue, sizeof (truevalue)},
1005.         {CKA_LABEL, publab, sizeof(publab)-1},
1006.         {CKA_ENCRYPT, &truevalue, sizeof(truevalue)},
1007.         {CKA_VERIFY, &truevalue, sizeof(truevalue)},
1008.         {CKA_PRIVATE, &falsevalue, sizeof(falsevalue)},
1009.         {CKA_MODULUS, RSA_PUB_N, RSA_PUB_N_LEN},
1010.         {CKA_PUBLIC_EXPONENT, RSA_PUB_E, RSA_PUB_E_LEN}
1011.     };
1013.     CK_MECHANISM mechanism = {CKM_RSA_PKCS, NULL_PTR, 0};
1015.     Result = C_FindObjectsInit(Session, PubKeyAttr, 4);
1016.     if (Result != CKR_OK)
1017.     {
1018.         return NULL;
1019.     }
1021.     Result = C_FindObjects(Session, &PubHandle, 1, &ObjCount);
1022.     C_FindObjectsFinal(Session);
1023.     if ((Result != CKR_OK) || (ObjCount == 0))
1024.     {
1025.         return NULL;
1026.     }
1028.     Result = C_GetAttributeValue(Session, PubHandle, PubKeyAttr, 9);
1029.     if (Result != CKR_OK)
1030.     {
1031.         return NULL;
1032.     }
1034.     PubKey = RSA_new();
1036.     PubKey->n = BN_bin2bn((const unsigned char*)PubKeyAttr[7].pValue, PubKeyAttr[7].ulValueLen, NULL);
1037.     PubKey->e = BN_bin2bn((const unsigned char*)PubKeyAttr[8].pValue, PubKeyAttr[8].ulValueLen, NULL);
1039.     return PubKey;
1040. }
1042. VOID FreeRSA(RSA *rsa)
1043. {
1044.     if (rsa != NULL)
1045.     {
1046.         RSA_free(rsa);
1047.     }
1048. }