CertificateExample.c

00001 /*
00002  *      Copyright (C) 2000,2001 Fabio Fiorina
00003  *
00004  * This file is part of GNUTLS.
00005  *
00006  * GNUTLS is free software; you can redistribute it and/or modify
00007  * it under the terms of the GNU General Public License as published by
00008  * the Free Software Foundation; either version 2 of the License, or
00009  * (at your option) any later version.
00010  *
00011  * GNUTLS is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  * GNU General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU General Public License
00017  * along with this program; if not, write to the Free Software
00018  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
00019  */
00020 
00021 
00022 /*****************************************************/
00023 /* File: CertificateExample.c                        */
00024 /* Description: An example on how to use the ASN1    */
00025 /*              parser with the Certificate.txt file */   
00026 /*****************************************************/
00027 
00028 #include <stdio.h>
00029 #include <string.h>
00030 #include <stdlib.h>
00031 #include "libtasn1.h"
00032 
00033 
00034 char *
00035 my_ltostr(long v,char *str)
00036 {
00037   long d,r;
00038   char temp[20];
00039   int count,k,start;
00040 
00041   if(v<0){
00042     str[0]='-';
00043     start=1;
00044     v=-v;
00045   }
00046   else start=0;
00047 
00048   count=0;
00049   do{
00050     d=v/10;
00051     r=v-d*10;
00052     temp[start+count]='0'+(char)r;
00053     count++;
00054     v=d;
00055   }while(v);
00056 
00057   for(k=0;k<count;k++) str[k+start]=temp[start+count-k-1];
00058   str[count+start]=0;
00059   return str;
00060 }
00061 
00062 /******************************************************/
00063 /* Function : get_name_type                           */
00064 /* Description: analyze a structure of type Name      */
00065 /* Parameters:                                        */
00066 /*   char *root: the structure identifier             */
00067 /*   char *answer: the string with elements like:     */
00068 /*                 "C=US O=gov"                       */ 
00069 /******************************************************/
00070 void
00071 get_Name_type(node_asn *cert_def,node_asn *cert,char *root, char *answer)
00072 {
00073   int k,k2,result,len;
00074   char name[128],str[1024],str2[1024],name2[128],counter[5],name3[128];
00075   ASN1_TYPE value=ASN1_TYPE_EMPTY;
00076   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE];
00077 
00078   answer[0]=0;
00079   k=1;
00080   do{
00081     strcpy(name,root);
00082     strcat(name,".rdnSequence.?");
00083     my_ltostr(k,counter);
00084     strcat(name,counter);
00085     len = sizeof(str) - 1;
00086     result=asn1_read_value(cert,name,str,&len);
00087     if(result==ASN1_ELEMENT_NOT_FOUND) break;
00088     k2=1;
00089     do{
00090       strcpy(name2,name);
00091       strcat(name2,".?");
00092       my_ltostr(k2,counter);
00093       strcat(name2,counter);
00094       len = sizeof(str) - 1;
00095       result=asn1_read_value(cert,name2,str,&len);
00096       if(result==ASN1_ELEMENT_NOT_FOUND) break;
00097       strcpy(name3,name2);
00098       strcat(name3,".type");
00099       len = sizeof(str) - 1;
00100       result=asn1_read_value(cert,name3,str,&len);
00101       strcpy(name3,name2);
00102       strcat(name3,".value");
00103       if(result==ASN1_SUCCESS){
00104       len = sizeof(str2) - 1;
00105       result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",
00106                     str2,&len);
00107       if(!strcmp(str,str2)){
00108         asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName",
00109                      &value);
00110         len = sizeof(str) - 1;
00111         asn1_read_value(cert,name3,str,&len);
00112               asn1_der_decoding(&value,str,len,errorDescription);
00113         len = sizeof(str) - 1;
00114         asn1_read_value(value,"",str,&len);  /* CHOICE */
00115         strcpy(name3,str);
00116         len = sizeof(str) - 1;
00117         asn1_read_value(value,name3,str,&len);
00118         str[len]=0;
00119         strcat(answer," C=");
00120         strcat(answer,str);
00121         asn1_delete_structure(&value);
00122       }
00123       else{
00124         len = sizeof(str2) - 1;
00125         result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName"
00126                       ,str2,&len);
00127         if(!strcmp(str,str2)){
00128           asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName"
00129                        ,&value);
00130           len = sizeof(str) - 1;
00131           asn1_read_value(cert,name3,str,&len);   
00132           asn1_der_decoding(&value,str,len,errorDescription);
00133           len = sizeof(str) - 1;
00134           asn1_read_value(value,"",str,&len);  /* CHOICE */
00135           strcpy(name3,str);
00136           len = sizeof(str) - 1;
00137           asn1_read_value(value,name3,str,&len);
00138           str[len]=0;
00139           strcat(answer," O=");
00140           strcat(answer,str);
00141           asn1_delete_structure(&value);
00142         }
00143         else{
00144           len = sizeof(str2) - 1;
00145           result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",str2,&len);
00146           if(!strcmp(str,str2)){
00147             asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value);
00148             len = sizeof(str) - 1;
00149             asn1_read_value(cert,name3,str,&len);
00150             asn1_der_decoding(&value,str,len,errorDescription);
00151             len = sizeof(str) - 1;
00152             asn1_read_value(value,"",str,&len);  /* CHOICE */
00153             strcpy(name3,str);
00154             len = sizeof(str) - 1;
00155             asn1_read_value(value,name3,str,&len);
00156             str[len]=0;
00157             strcat(answer," OU=");
00158             strcat(answer,str);
00159             asn1_delete_structure(&value);
00160           }
00161         }
00162       }
00163       }
00164       k2++;
00165     }while(1);
00166     k++;
00167   }while(1);
00168 }
00169 
00170 
00171 /******************************************************/
00172 /* Function : create_certificate                      */
00173 /* Description: creates a certificate named           */
00174 /*              "certificate1". Values are the same   */
00175 /*              as in rfc2459 Appendix D.1            */
00176 /* Parameters:                                        */
00177 /*   unsigned char *der: contains the der encoding    */
00178 /*   int *der_len: number of bytes of der string      */ 
00179 /******************************************************/
00180 void
00181 create_certificate(node_asn *cert_def,unsigned char *der,int *der_len)
00182 {
00183   int result,k,len;
00184   unsigned char str[1024],*str2;
00185   ASN1_TYPE cert1=ASN1_TYPE_EMPTY;
00186   ASN1_TYPE value=ASN1_TYPE_EMPTY;
00187   ASN1_TYPE param=ASN1_TYPE_EMPTY;
00188   ASN1_TYPE constr=ASN1_TYPE_EMPTY;
00189   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE];
00190   int max_len;
00191 
00192   max_len=*der_len;
00193 
00194   result=asn1_create_element(cert_def,"PKIX1Implicit88.Certificate",&cert1);
00195  
00196   /* Use the next 3 lines to visit the empty certificate */
00197   /* printf("-----------------\n");
00198      asn1_visit_tree(cert1,"");   
00199      printf("-----------------\n"); */
00200 
00201   /* version: v3(2) */  
00202   result=asn1_write_value(cert1,"tbsCertificate.version","v3",0); 
00203 
00204   /* serialNumber: 17 */    
00205   result=asn1_write_value(cert1,"tbsCertificate.serialNumber","17",0); 
00206 
00207   /* signature: dsa-with-sha1 */
00208   len = sizeof(str) - 1;
00209   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str,&len);
00210   result=asn1_write_value(cert1,"tbsCertificate.signature.algorithm",
00211                  str,1);    
00212   
00213   result=asn1_write_value(cert1,"tbsCertificate.signature.parameters",
00214                  NULL,0);
00215 
00216 
00217   /* issuer: Country="US" Organization="gov" OrganizationUnit="nist" */
00218   result=asn1_write_value(cert1,"tbsCertificate.issuer","rdnSequence",12);
00219 
00220   result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence","NEW",1);
00221   result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST","NEW",1);
00222   /* C */
00223   len = sizeof(str) - 1;
00224   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",str,&len);
00225   result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",str,1);
00226   result=asn1_create_element(cert_def,"PKIX1Implicit88.X520countryName",
00227                     &value);
00228   result=asn1_write_value(value,"","US",2);
00229   *der_len = max_len;
00230   result=asn1_der_coding(value,"",der,der_len,errorDescription);
00231   asn1_delete_structure(&value);
00232   result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
00233 
00234 
00235   result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence","NEW",1);
00236   result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST","NEW",1);
00237   /* O */
00238   len = sizeof(str) - 1;
00239   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName",str,&len);
00240   result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",str,1);
00241   result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName",
00242                     &value);
00243   result=asn1_write_value(value,"","printableString",1);
00244   result=asn1_write_value(value,"printableString","gov",3);
00245   *der_len = max_len;
00246   result=asn1_der_coding(value,"",der,der_len,errorDescription);
00247   asn1_delete_structure(&value);
00248   result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
00249 
00250 
00251   result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence","NEW",1);
00252   result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST","NEW",1);
00253 
00254   /* OU */
00255   len = sizeof(str) - 1;
00256   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",
00257                 str,&len);
00258   result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",str,1);
00259   result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value);
00260   result=asn1_write_value(value,"","printableString",1);
00261   result=asn1_write_value(value,"printableString","nist",4);
00262   *der_len = max_len;
00263   result=asn1_der_coding(value,"",der,der_len,errorDescription);
00264   asn1_delete_structure(&value);
00265   result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
00266 
00267 
00268   /* validity */
00269   result=asn1_write_value(cert1,"tbsCertificate.validity.notBefore","utcTime",1);
00270   result=asn1_write_value(cert1,"tbsCertificate.validity.notBefore.utcTime","970630000000Z",1);
00271 
00272   result=asn1_write_value(cert1,"tbsCertificate.validity.notAfter","utcTime",1);
00273   result=asn1_write_value(cert1,"tbsCertificate.validity.notAfter.utcTime","971231000000Z",1);
00274 
00275 
00276 
00277   /* subject: Country="US" Organization="gov" OrganizationUnit="nist" */
00278   result=asn1_write_value(cert1,"tbsCertificate.subject","rdnSequence",1);
00279 
00280   result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence","NEW",1);
00281   result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST","NEW",1);
00282   /* C */
00283   len = sizeof(str) - 1;
00284   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",str,&len);
00285   result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",str,1);
00286   result=asn1_create_element(cert_def,"PKIX1Implicit88.X520countryName",
00287                     &value);
00288   result=asn1_write_value(value,"","US",2);
00289   *der_len = max_len;
00290   result=asn1_der_coding(value,"",der,der_len,errorDescription);
00291   asn1_delete_structure(&value);
00292   result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",der,*der_len);
00293 
00294 
00295   result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence","NEW",4);
00296   result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST","NEW",4);
00297   /* O */
00298   len = sizeof(str) - 1;
00299   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName",str,&len);
00300   result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",str,1);
00301   result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName",
00302                     &value);
00303   result=asn1_write_value(value,"","printableString",1);
00304   result=asn1_write_value(value,"printableString","gov",3);
00305   *der_len = max_len;
00306   result=asn1_der_coding(value,"",der,der_len,errorDescription);
00307   asn1_delete_structure(&value);
00308   result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",der,*der_len);
00309 
00310 
00311   result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence","NEW",4);
00312   result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST","NEW",4);
00313   /* OU */
00314   len = sizeof(str) - 1;
00315   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",
00316                 str,&len);
00317   result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",str,1);
00318   result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value);
00319   result=asn1_write_value(value,"","printableString",1);
00320   result=asn1_write_value(value,"printableString","nist",4);
00321   *der_len = max_len;
00322   result=asn1_der_coding(value,"",der,der_len,errorDescription);
00323   asn1_delete_structure(&value);
00324   result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",der,*der_len);
00325 
00326 
00327   /* subjectPublicKeyInfo: dsa with parameters=Dss-Parms */
00328   len = sizeof(str) - 1;
00329   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa",str,&len);
00330   result=asn1_write_value(cert1,"tbsCertificate.subjectPublicKeyInfo.algorithm.algorithm",str,1); 
00331   result=asn1_create_element(cert_def,"PKIX1Implicit88.Dss-Parms",&param);
00332   str2="\xd4\x38"; /* only an example */
00333   result=asn1_write_value(param,"p",str2,128);
00334   str2="\xd4\x38"; /* only an example */
00335   result=asn1_write_value(param,"q",str2,20);
00336   str2="\xd4\x38"; /* only an example */
00337   result=asn1_write_value(param,"g",str2,128);
00338   *der_len = max_len;
00339   result=asn1_der_coding(param,"",der,der_len,errorDescription);
00340   asn1_delete_structure(&param);
00341   result=asn1_write_value(cert1,"tbsCertificate.subjectPublicKeyInfo.algorithm.parameters",der,*der_len); 
00342 
00343 
00344   /* subjectPublicKey */
00345   str2="\x02\x81"; /* only an example */
00346   result=asn1_write_value(cert1,"tbsCertificate.subjectPublicKeyInfo.subjectPublicKey",str2,1048);
00347 
00348   result=asn1_write_value(cert1,"tbsCertificate.issuerUniqueID",NULL,0);  /* NO OPTION */
00349   result=asn1_write_value(cert1,"tbsCertificate.subjectUniqueID",NULL,0); /* NO OPTION */
00350 
00351   /* extensions */
00352   result=asn1_write_value(cert1,"tbsCertificate.extensions","NEW",1); 
00353   len = sizeof(str) - 1;
00354   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-ce-basicConstraints",
00355                 str,&len);
00356   result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.extnID",str,1); /*   basicConstraints */  
00357   result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.critical","TRUE",1); 
00358   result=asn1_create_element(cert_def,"PKIX1Implicit88.BasicConstraints",&constr);
00359   result=asn1_write_value(constr,"cA","TRUE",1); 
00360   result=asn1_write_value(constr,"pathLenConstraint",NULL,0); 
00361   *der_len = max_len; 
00362   result=asn1_der_coding(constr,"",der,der_len,errorDescription);
00363   result=asn1_delete_structure(&constr);
00364   result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.extnValue",der,*der_len); 
00365 
00366 
00367   result=asn1_write_value(cert1,"tbsCertificate.extensions","NEW",1); 
00368   len = sizeof(str) - 1;
00369   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-ce-subjectKeyIdentifier",
00370                 str,&len);
00371   result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.extnID",str,1); /* subjectKeyIdentifier */ 
00372   result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.critical","FALSE",1); 
00373   str2="\x04\x14\xe7\x26\xc5"; /* only an example */
00374   result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.extnValue",str2,22); 
00375 
00376 
00377   /* signatureAlgorithm: dsa-with-sha  */
00378   len = sizeof(str) - 1;
00379   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str,&len);
00380   result=asn1_write_value(cert1,"signatureAlgorithm.algorithm",str,1); 
00381   result=asn1_write_value(cert1,"signatureAlgorithm.parameters",NULL,0); /* NO OPTION */  
00382 
00383 
00384   /* signature */
00385   *der_len = max_len;
00386   result=asn1_der_coding(cert1,"tbsCertificate",der,der_len
00387                          ,errorDescription);
00388   if(result!=ASN1_SUCCESS){
00389     printf("\n'tbsCertificate' encoding creation: ERROR\n");
00390   }
00391   /* add the lines for the signature on der[0]..der[der_len-1]: result in str2 */
00392   result=asn1_write_value(cert1,"signature",str2,368); /* dsa-with-sha */ 
00393   
00394 
00395   /* Use the next 3 lines to visit the certificate */
00396   /* printf("-----------------\n");   
00397      asn1_visit_tree(cert1,"");  
00398      printf("-----------------\n"); */
00399 
00400   *der_len = max_len;
00401   result=asn1_der_coding(cert1,"",der,der_len,errorDescription);
00402   if(result!=ASN1_SUCCESS){
00403     printf("\n'certificate' encoding creation: ERROR\n");
00404     return;
00405   }
00406 
00407   /* Print the 'Certificate1' DER encoding */ 
00408   printf("-----------------\nCertificate Encoding:\nNumber of bytes=%i\n",*der_len);
00409   for(k=0;k<*der_len;k++) printf("%02x ",der[k]);  
00410   printf("\n-----------------\n");
00411 
00412   /* Clear the "certificate1" structure */
00413   asn1_delete_structure(&cert1);
00414 }
00415 
00416 
00417 
00418 /******************************************************/
00419 /* Function : get_certificate                         */
00420 /* Description: creates a certificate named           */
00421 /*              "certificate2" from a der encoding    */
00422 /*              string                                */
00423 /* Parameters:                                        */
00424 /*   unsigned char *der: the encoding string          */
00425 /*   int der_len: number of bytes of der string      */ 
00426 /******************************************************/
00427 void
00428 get_certificate(node_asn *cert_def,unsigned char *der,int der_len)
00429 {
00430   int result,len,start,end;
00431   unsigned char str[1024],str2[1024];
00432   ASN1_TYPE cert2=ASN1_TYPE_EMPTY;
00433   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE];
00434 
00435   asn1_create_element(cert_def,"PKIX1Implicit88.Certificate",&cert2);
00436 
00437   result=asn1_der_decoding(&cert2,der,der_len,errorDescription);
00438 
00439   if(result!=ASN1_SUCCESS){
00440     printf("Problems with DER encoding\n");
00441     return;
00442   }
00443    
00444 
00445   /* issuer */
00446   get_Name_type(cert_def,cert2,"tbsCertificate.issuer",str);
00447   printf("certificate:\nissuer :%s\n",str);
00448   /* subject */
00449   get_Name_type(cert_def,cert2,"tbsCertificate.subject",str);
00450   printf("subject:%s\n",str);
00451 
00452 
00453   /* Verify sign */
00454   len = sizeof(str) - 1;
00455   result=asn1_read_value(cert2,"signatureAlgorithm.algorithm"
00456                 ,str,&len);
00457 
00458   len = sizeof(str2) - 1;
00459   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str2,&len);
00460   if(!strcmp(str,str2)){  /* dsa-with-sha */
00461 
00462     result=asn1_der_decoding_startEnd(cert2,der,der_len,
00463                        "tbsCertificate",&start,&end);
00464 
00465     /* add the lines to calculate the sha on der[start]..der[end] */
00466 
00467     len = sizeof(str) - 1;
00468     result=asn1_read_value(cert2,"signature",str,&len);
00469 
00470     /* compare the previous value to signature ( with issuer public key) */ 
00471   }
00472 
00473   /* Use the next 3 lines to visit the certificate */
00474   /*   printf("-----------------\n");   
00475      asn1_visit_tree(cert2,"");  
00476      printf("-----------------\n"); */
00477 
00478 
00479   /* Clear the "certificate2" structure */
00480   asn1_delete_structure(&cert2);
00481 }
00482 
00483 #include "pkix_asn1_tab.c"
00484 
00485 /********************************************************/
00486 /* Function : main                                      */
00487 /* Description: reads the certificate description.      */
00488 /*              Creates a certificate and calculate     */
00489 /*              the der encoding. After that creates    */  
00490 /*              another certificate from der string     */
00491 /********************************************************/
00492 int
00493 main(int argc,char *argv[])
00494 {
00495   int result,der_len;
00496   unsigned char der[1024];
00497   ASN1_TYPE PKIX1Implicit88=ASN1_TYPE_EMPTY;
00498   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE];
00499 
00500   if(1)
00501     result=asn1_array2tree(pkix_asn1_tab,&PKIX1Implicit88,errorDescription); 
00502   else
00503     result=asn1_parser2tree("pkix.asn",&PKIX1Implicit88,errorDescription);
00504 
00505   if(result != ASN1_SUCCESS){
00506     libtasn1_perror(result);
00507     printf("%s",errorDescription);
00508     exit(1);
00509   }
00510 
00511   
00512   /* Use the following 3 lines to visit the PKIX1Implicit structures */
00513   /* printf("-----------------\n");
00514      asn1_visit_tree(PKIX1Implicit88,"PKIX1Implicit88");   
00515      printf("-----------------\n"); */
00516 
00517   der_len=1024;
00518   create_certificate(PKIX1Implicit88,der,&der_len);
00519 
00520   get_certificate(PKIX1Implicit88,der,der_len);
00521 
00522   /* Clear the "PKIX1Implicit88" structures */
00523   asn1_delete_structure(&PKIX1Implicit88);
00524 
00525   return 0;
00526 }
00527 
00528 
00529 
00530 
00531 
00532 
00533 
00534 
00535