src/CrlExample.c

   1 /*
   2  *      Copyright (C) 2006 Free Software Foundation
   3  *      Copyright (C) 2000,2001 Fabio Fiorina
   4  *
   5  * This file is part of LIBTASN1.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20  * 02110-1301, USA
  21  */
  22
  23
  24 /*****************************************************/
  25 /* File: CrlExample.c                                */
  26 /* Description: An example on how to use the ASN1    */
  27 /*              parser with the Certificate.txt file */
  28 /*****************************************************/
  29
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <stdlib.h>
  33 #include "libtasn1.h"
  34
  35
  36
  37 char *
  38 my_ltostr(long v,char *str)
  39 {
  40   long d,r;
  41   char temp[20];
  42   int count,k,start;
  43
  44   if(v<0){
  45     str[0]='-';
  46     start=1;
  47     v=-v;
  48   }
  49   else start=0;
  50
  51   count=0;
  52   do{
  53     d=v/10;
  54     r=v-d*10;
  55     temp[start+count]='0'+(char)r;
  56     count++;
  57     v=d;
  58   }while(v);
  59
  60   for(k=0;k<count;k++) str[k+start]=temp[start+count-k-1];
  61   str[count+start]=0;
  62   return str;
  63 }
  64
  65
  66 /******************************************************/
  67 /* Function : get_name_type                           */
  68 /* Description: analyze a structure of type Name      */
  69 /* Parameters:                                        */
  70 /*   char *root: the structure identifier             */
  71 /*   char *answer: the string with elements like:     */
  72 /*                 "C=US O=gov"                       */
  73 /******************************************************/
  74 void
  75 get_Name_type(node_asn *cert_def,node_asn *cert,char *root, char *answer)
  76 {
  77   int k,k2,result,len;
  78   char name[128],str[1024],str2[1024],name2[128],counter[5],name3[128];
  79   ASN1_TYPE value=ASN1_TYPE_EMPTY;
  80   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE];
  81
  82   answer[0]=0;
  83   k=1;
  84   do{
  85     strcpy(name,root);
  86     strcat(name,".rdnSequence.?");
  87     my_ltostr(k,counter);
  88     strcat(name,counter);
  89
  90     len = sizeof(str)-1;
  91     result=asn1_read_value(cert,name,str,&len);
  92     if(result==ASN1_ELEMENT_NOT_FOUND) break;
  93     k2=1;
  94     do{
  95       strcpy(name2,name);
  96       strcat(name2,".?");
  97       my_ltostr(k2,counter);
  98       strcat(name2,counter);
  99
 100       len = sizeof(str)-1;
 101       result=asn1_read_value(cert,name2,str,&len);
 102       if(result==ASN1_ELEMENT_NOT_FOUND) break;
 103       strcpy(name3,name2);
 104       strcat(name3,".type");
 105
 106       len = sizeof(str)-1;
 107       result=asn1_read_value(cert,name3,str,&len);
 108       strcpy(name3,name2);
 109       strcat(name3,".value");
 110       if(result==ASN1_SUCCESS){
 111         len = sizeof(str2);
 112         result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",
 113                           str2,&len);
 114         if(!strcmp(str,str2)){
 115           asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName",
 116                               &value);
 117           len = sizeof(str)-1;
 118           asn1_read_value(cert,name3,str,&len);
 119           result=asn1_der_decoding(&value,str,len,errorDescription);
 120
 121           len = sizeof(str)-1;
 122           asn1_read_value(value,"",str,&len);  /* CHOICE */
 123
 124           strcpy(name3,str);
 125
 126           len = sizeof(str)-1;
 127           asn1_read_value(value,name3,str,&len);
 128           str[len]=0;
 129           strcat(answer," C=");
 130           strcat(answer,str);
 131
 132           asn1_delete_structure(&value);
 133         }
 134         else{
 135           len = sizeof(str2);
 136           result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName"
 137                             ,str2,&len);
 138           if(!strcmp(str,str2)){
 139             asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName"
 140                              ,&value);
 141
 142             len = sizeof(str)-1;
 143             asn1_read_value(cert,name3,str,&len);
 144             asn1_der_decoding(&value,str,len,errorDescription);
 145             len = sizeof(str)-1;
 146             asn1_read_value(value,"",str,&len);  /* CHOICE */
 147             strcpy(name3,str);
 148             len = sizeof(str)-1;
 149             asn1_read_value(value,name3,str,&len);
 150             str[len]=0;
 151             strcat(answer," O=");
 152             strcat(answer,str);
 153             asn1_delete_structure(&value);
 154           }
 155           else{
 156             len = sizeof(str2);
 157             result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",str2,&len);
 158             if(!strcmp(str,str2)){
 159               asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value);
 160               len = sizeof(str)-1;
 161               asn1_read_value(cert,name3,str,&len);
 162               asn1_der_decoding(&value,str,len,errorDescription);
 163               len = sizeof(str)-1;
 164               asn1_read_value(value,"",str,&len);  /* CHOICE */
 165               strcpy(name3,str);
 166               len = sizeof(str)-1;
 167               asn1_read_value(value,name3,str,&len);
 168               str[len]=0;
 169               strcat(answer," OU=");
 170               strcat(answer,str);
 171               asn1_delete_structure(&value);
 172             }
 173           }
 174         }
 175       }
 176       k2++;
 177     }while(1);
 178     k++;
 179   }while(1);
 180 }
 181
 182
 183 /******************************************************/
 184 /* Function : create_certificate                      */
 185 /* Description: creates a certificate named           */
 186 /*              "certificate1". Values are the same   */
 187 /*              as in rfc2459 Appendix D.1            */
 188 /* Parameters:                                        */
 189 /*   unsigned char *der: contains the der encoding    */
 190 /*   int *der_len: number of bytes of der string      */
 191 /******************************************************/
 192 void
 193 create_CRL(node_asn *cert_def, unsigned char *der,int *der_len)
 194 {
 195   int result,k,len;
 196   unsigned char str[1024],*str2;
 197   ASN1_TYPE crl=ASN1_TYPE_EMPTY;
 198   ASN1_TYPE value=ASN1_TYPE_EMPTY;
 199   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE];
 200   int max_len;
 201
 202   max_len=*der_len;
 203
 204   result=asn1_create_element(cert_def,"PKIX1Implicit88.CertificateList",&crl);
 205
 206   /* Use the next 3 lines to visit the empty certificate */
 207   /*  printf("-----------------\n");
 208    asn1_visit_tree(crl,"");
 209    printf("-----------------\n"); */
 210
 211
 212   /* version: v2(1) */
 213   result=asn1_write_value(crl,"tbsCertList.version","v2",0);
 214
 215
 216   /* signature: dsa-with-sha */
 217   len = sizeof(str)-1;
 218   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str,&len);
 219   result=asn1_write_value(crl,"tbsCertList.signature.algorithm",str,1);
 220   result=asn1_write_value(crl,"tbsCertList.signature.parameters",NULL,0);
 221
 222
 223   /* issuer: Country="US" Organization="gov" OrganizationUnit="nist" */
 224   result=asn1_write_value(crl,"tbsCertList.issuer","rdnSequence",1);
 225
 226   result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence","NEW",1);
 227   result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST","NEW",1);
 228   /* C */
 229   len = sizeof(str)-1;
 230   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",str,&len);
 231   result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",str,1);
 232   result=asn1_create_element(cert_def,"PKIX1Implicit88.X520countryName",
 233                           &value);
 234   result=asn1_write_value(value,"","US",2);
 235   *der_len=max_len;
 236   result=asn1_der_coding(value,"",der,der_len,errorDescription);
 237
 238   asn1_delete_structure(&value);
 239   result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
 240
 241
 242   result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence","NEW",4);
 243   result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST","NEW",4);
 244   /* O */
 245   len = sizeof(str)-1;
 246   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName",str,&len);
 247   result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",str,8);
 248   result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName",
 249                           &value);
 250   result=asn1_write_value(value,"","printableString",1);
 251   result=asn1_write_value(value,"printableString","gov",3);
 252   *der_len=max_len;
 253   result=asn1_der_coding(value,"",der,der_len,errorDescription);
 254   asn1_delete_structure(&value);
 255   result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
 256
 257
 258   result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence","NEW",1);
 259   result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST","NEW",1);
 260   /* OU */
 261   len = sizeof(str)-1;
 262   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",
 263                     str,&len);
 264   result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",str,1);
 265   result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value);
 266   result=asn1_write_value(value,"","printableString",1);
 267   result=asn1_write_value(value,"printableString","nist",4);
 268   *der_len=max_len;
 269   result=asn1_der_coding(value,"",der,der_len,errorDescription);
 270   asn1_delete_structure(&value);
 271   result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
 272
 273
 274   /* validity */
 275   result=asn1_write_value(crl,"tbsCertList.thisUpdate","utcTime",1);
 276   result=asn1_write_value(crl,"tbsCertList.thisUpdate.utcTime","970801000000Z",1);
 277
 278   result=asn1_write_value(crl,"tbsCertList.nextUpdate","utcTime",1);
 279   result=asn1_write_value(crl,"tbsCertList.nextUpdate.utcTime","970808000000Z",1);
 280
 281
 282   /* revokedCertificates */
 283   result=asn1_write_value(crl,"tbsCertList.revokedCertificates","NEW",1);
 284   str[0]=18;
 285   result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.userCertificate",str,1);
 286   result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.revocationDate","utcTime",1);
 287   result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.revocationDate.utcTime","970731000000Z",1);
 288
 289   result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.crlEntryExtensions","NEW",1);
 290   len = sizeof(str)-1;
 291   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-ce-cRLReasons",
 292                     str,&len);
 293   result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.extnID",str,1); /* reasonCode */
 294   result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.critical","FALSE",1);
 295   str2="\x0a\x01\x01";
 296   result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.extnValue",str2,3);
 297
 298
 299   /* crlExtensions */
 300   result=asn1_write_value(crl,"tbsCertList.crlExtensions",NULL,0);
 301
 302
 303   /* signatureAlgorithm: dsa-with-sha  */
 304   len = sizeof(str)-1;
 305   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str,&len);
 306   result=asn1_write_value(crl,"signatureAlgorithm.algorithm",str,1);
 307   result=asn1_write_value(crl,"signatureAlgorithm.parameters",NULL,0); /* NO OPTION */
 308
 309   /* signature */
 310   *der_len=max_len;
 311   result=asn1_der_coding(crl,"tbsCertList",der,der_len,errorDescription);
 312   if(result!=ASN1_SUCCESS){
 313     printf("\n'tbsCertList' encoding creation: ERROR\n");
 314     return;
 315   }
 316
 317   /* add the lines for the signature on der[0]..der[der_len-1]: result in str2 */
 318   result=asn1_write_value(crl,"signature",str2,46*8);
 319
 320
 321   /* Use the next 3 lines to visit the certificate */
 322   /* printf("-----------------\n");
 323      asn1_visit_tree(crl,"");
 324      printf("-----------------\n"); */
 325
 326   *der_len=max_len;
 327   result=asn1_der_coding(crl,"",der,der_len,errorDescription);
 328   if(result!=ASN1_SUCCESS){
 329     printf("\n'crl1' encoding creation: ERROR\n");
 330     return;
 331   }
 332
 333   /* Print the 'Certificate1' DER encoding */
 334   printf("-----------------\nCrl1 Encoding:\nNumber of bytes=%i\n",*der_len);
 335   for(k=0;k<*der_len;k++) printf("%02x ",der[k]);
 336   printf("\n-----------------\n");
 337
 338   /* Clear the "certificate1" structure */
 339   asn1_delete_structure(&crl);
 340 }
 341
 342
 343
 344 /******************************************************/
 345 /* Function : get_certificate                         */
 346 /* Description: creates a certificate named           */
 347 /*              "certificate2" from a der encoding    */
 348 /*              string                                */
 349 /* Parameters:                                        */
 350 /*   unsigned char *der: the encoding string          */
 351 /*   int der_len: number of bytes of der string      */
 352 /******************************************************/
 353 void
 354 get_CRL(node_asn *cert_def,unsigned char *der,int der_len)
 355 {
 356   int result,len,start,end;
 357   unsigned char str[1024],str2[1024];
 358   ASN1_TYPE crl2=ASN1_TYPE_EMPTY;
 359   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE];
 360
 361
 362   asn1_create_element(cert_def,"PKIX1Implicit88.CertificateList",&crl2);
 363
 364   result=asn1_der_decoding(&crl2,der,der_len,errorDescription);
 365
 366   if(result!=ASN1_SUCCESS){
 367     printf("Problems with DER encoding\n");
 368     return;
 369   }
 370
 371
 372   /* issuer */
 373   get_Name_type(cert_def,crl2,"tbsCertList.issuer",str);
 374   printf("crl2:\nissuer: %s\n",str);
 375
 376
 377   /* Verify sign */
 378   len = sizeof(str)-1;
 379   result=asn1_read_value(crl2,"signatureAlgorithm.algorithm",str,&len);
 380
 381   result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str2,&len);
 382   if(!strcmp(str,str2)){  /* dsa-with-sha */
 383
 384     result=asn1_der_decoding_startEnd(crl2,der,der_len,
 385                              "tbsCertList",&start,&end);
 386
 387     /* add the lines to calculate the sha on der[start]..der[end] */
 388
 389     result=asn1_read_value(crl2,"signature",str,&len);
 390
 391     /* compare the previous value to signature ( with issuer public key) */
 392   }
 393
 394   /* Use the next 3 lines to visit the certificate */
 395   /* printf("-----------------\n");
 396      asn1_visit_tree(crl2,"");
 397      printf("-----------------\n"); */
 398
 399
 400   /* Clear the "crl2" structure */
 401   asn1_delete_structure(&crl2);
 402 }
 403
 404 #include "pkix_asn1_tab.c"
 405
 406 /********************************************************/
 407 /* Function : main                                      */
 408 /* Description: reads the certificate description.      */
 409 /*              Creates a certificate and calculate     */
 410 /*              the der encoding. After that creates    */
 411 /*              another certificate from der string     */
 412 /********************************************************/
 413 int
 414 main(int argc,char *argv[])
 415 {
 416   int result,der_len;
 417   unsigned char der[1024];
 418   ASN1_TYPE PKIX1Implicit88=ASN1_TYPE_EMPTY;
 419   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE];
 420
 421   if(1)
 422     result=asn1_array2tree(pkix_asn1_tab,&PKIX1Implicit88,errorDescription);
 423   else
 424     result=asn1_parser2tree("pkix.asn",&PKIX1Implicit88,errorDescription);
 425
 426   if(result != ASN1_SUCCESS){
 427     libtasn1_perror(result);
 428     printf("%s\n",errorDescription);
 429     exit(1);
 430   }
 431
 432   /* Use the following 3 lines to visit the PKIX1Implicit structures */
 433   /* printf("-----------------\n");
 434      asn1_visit_tree(cert_def,"PKIX1Implicit88");
 435      printf("-----------------\n"); */
 436
 437   der_len=1024;
 438   create_CRL(PKIX1Implicit88,der,&der_len);
 439
 440
 441   get_CRL(PKIX1Implicit88,der,der_len);
 442
 443   /* Clear the "PKIX1Implicit88" structures */
 444   asn1_delete_structure(&PKIX1Implicit88);
 445
 446   return 0;
 447 }
 448
 449
 450
 451
 452
 453
 454
 455
 456