git.sur5r.net Git - openldap/blob - servers/ldapd/certificate.c

   1 /*
   2  * certificate.c - ldap version of quipu certificate syntax handler
   3  *                 donated by Eric Rosenquist and BNR
   4  */
   5
   6 #include "portable.h"
   7
   8 #include <stdio.h>
   9
  10 #include <ac/ctype.h>
  11 #include <ac/socket.h>
  12 #include <ac/string.h>
  13
  14 #include <quipu/commonarg.h>
  15 #include <quipu/attrvalue.h>
  16 #include <quipu/ds_error.h>
  17 #include <quipu/ds_search.h>
  18 #include <quipu/dap2.h>
  19 #include <quipu/dua.h>
  20 extern sntx_table *get_syntax_table( short int sntx );
  21 extern PE asn2pe( char * );
  22
  23 #include "lber.h"
  24 #include "ldap.h"
  25 #include "common.h"
  26
  27 int
  28 ldap_certif_print( PS ps, struct certificate *parm, int format )
  29 {
  30         Debug( LDAP_DEBUG_TRACE, "ldap_certif_print()\n", 0, 0, 0 );
  31
  32 /*
  33  *      An ldap certificate looks like this:
  34  *
  35  *      <certificate> ::= <version> '#' <serial> '#' <signature-algorithm-id>
  36  *                   '#' <issuer> '#' <validity> '#' <subject>
  37  *                   '#' <public-key-info> '#' <encrypted-sign-value>
  38  *      <version> ::= <integervalue>
  39  *      <serial> ::= <integervalue>
  40  *      <signature-algorithm-id> ::= <algorithm-id>
  41  *      <issuer> ::= an encoded Distinguished Name
  42  *      <validity> ::= <not-before-time> '#' <not-after-time>
  43  *      <not-before-time> ::= <utc-time>
  44  *      <not-after-time> ::= <utc-time>
  45  *      <algorithm-parameters> ::=  <null> | <integervalue> |
  46  *                               '{ASN}' <hex-string>
  47  *      <subject> ::= an encoded Distinguished Name
  48  *      <public-key-info> ::= <algorithm-id> '#' <encrypted-sign-value>
  49  *      <encrypted-sign-value> ::= <hex-string> | <hex-string> '-' <d>
  50  *      <algorithm-id> ::= <oid> '#' <algorithm-parameters>
  51  *      <utc-time> ::= an encoded UTCTime value
  52  *      <hex-string> ::= <hex-digit> | <hex-digit> <hex-string>
  53  */
  54
  55         ps_printf(ps, "%d#%d#", parm->version, parm->serial);
  56
  57         ldap_print_algid(ps, &(parm->sig.alg), format);
  58
  59         dn_print_real(ps, parm->issuer, format);
  60         ps_printf(ps, "#");
  61
  62         utcprint(ps, parm->valid.not_before, format);
  63         ps_printf(ps, "#");
  64         utcprint(ps, parm->valid.not_after, format);
  65         ps_printf(ps, "#");
  66
  67         dn_print_real(ps, parm->subject, format);
  68         ps_printf(ps, "#");
  69
  70         ldap_print_algid(ps, &(parm->key.alg), format);
  71         print_encrypted(ps, parm->key.value, parm->key.n_bits, format);
  72
  73         print_encrypted(ps, parm->sig.encrypted, parm->sig.n_bits, format);
  74 }
  75
  76 void
  77 ldap_print_algid( PS ps, struct alg_id *parm, int format )
  78 {
  79   ps_printf(ps, "%s#", oid2name (parm->algorithm, OIDPART));
  80
  81   switch(parm->p_type) {
  82      case ALG_PARM_ABSENT:
  83        if(parm->asn != NULLPE)
  84              pe_print(ps, parm->asn, format);
  85        ps_printf(ps, "#");
  86        break;
  87      case ALG_PARM_NUMERIC:
  88        if (format == READOUT)
  89          ps_printf(ps, "%d#", parm->un.numeric);
  90        else
  91          ps_printf(ps, "%d#", parm->un.numeric);
  92        break;
  93       default:
  94        if (format == READOUT)
  95        {
  96          if ((parm->asn->pe_class == PE_CLASS_UNIV)
  97            &&(parm->asn->pe_form  == PE_FORM_PRIM)
  98            &&(parm->asn->pe_id    == PE_PRIM_INT))
  99            ps_printf(ps, "%d", prim2num(parm->asn));
 100          else if ((parm->asn->pe_class == PE_CLASS_UNIV)
 101            &&(parm->asn->pe_form  == PE_FORM_PRIM)
 102            &&(parm->asn->pe_id    == PE_PRIM_NULL))
 103            ps_printf(ps, "NULL");
 104          else
 105          {
 106            vpushquipu (ps);
 107            vunknown(parm->asn);
 108            vpopquipu ();
 109          }
 110        }
 111        else
 112        {
 113         /* This routine will print a {ASN} prefix */
 114          pe_print(ps, parm->asn, format);
 115        }
 116        ps_printf(ps, "#");
 117    }
 118 }
 119
 120 struct certificate *
 121 ldap_str2cert( char *str )
 122 {
 123 struct certificate *result;
 124 char *ptr;
 125 OID oid;
 126
 127   Debug( LDAP_DEBUG_TRACE, "ldap_str2cert(%s)\n", str, 0, 0 );
 128
 129   result = (struct certificate *) calloc(1, sizeof(*result));
 130
 131   /* version */
 132   ptr = strchr(str, '#');
 133   if (ptr == NULLCP)
 134   {
 135     parse_error("version not present",NULLCP);
 136     cert_free(result);
 137     return (struct certificate *) 0;
 138   }
 139   *ptr++ = '\0';
 140   result->version = atoi(str);
 141
 142   /* serial number */
 143   str = ptr;
 144   ptr = strchr(str, '#');
 145   if (ptr == NULLCP)
 146   {
 147     parse_error("serial number not present",NULLCP);
 148     cert_free(result);
 149     return (struct certificate *) 0;
 150   }
 151   *ptr++ = '\0';
 152   result->serial = atoi(str);
 153
 154   /* signature algorithm id - oid */
 155   str = ptr;
 156   ptr = strchr(str, '#');
 157   if (ptr == NULLCP)
 158   {
 159     parse_error("signature algorithm id not present",NULLCP);
 160     cert_free(result);
 161     return (struct certificate *) 0;
 162   }
 163   *ptr++ = '\0';
 164   oid = name2oid(SkipSpace(str));
 165   if (oid == NULLOID)
 166   {
 167     parse_error("Bad algorithm identifier (SIGNED Value)",NULLCP);
 168     cert_free(result);
 169     return (struct certificate *) 0;
 170   }
 171   result->sig.alg.algorithm = oid;
 172   result->alg.algorithm     = oid_cpy(oid);
 173
 174   /* signature algorithm id - parameters */
 175   str = ptr;
 176   ptr = strchr(str, '#');
 177   if (ptr == NULLCP)
 178   {
 179     parse_error("algorithm id parameters not present",NULLCP);
 180     cert_free(result);
 181     return (struct certificate *) 0;
 182   }
 183   *ptr++ = '\0';
 184   ldap_str2alg(str, &(result->sig.alg));
 185   ldap_str2alg(str, &(result->alg));
 186
 187   /* issuer */
 188   str = ptr;
 189   ptr = strchr(str, '#');
 190   if (ptr == NULLCP)
 191   {
 192     parse_error("Issuer not present",NULLCP);
 193     cert_free(result);
 194     return (struct certificate *) 0;
 195   }
 196   *ptr++ = '\0';
 197   result->issuer = ldap_str2dn(str);
 198
 199   /* validity - not before */
 200   str = ptr;
 201   ptr = strchr(str, '#');
 202   if (ptr == NULLCP)
 203   {
 204     parse_error("Start time not present",NULLCP);
 205     cert_free(result);
 206     return (struct certificate *) 0;
 207   }
 208   *ptr++ = '\0';
 209   result->valid.not_before = strdup(str);
 210
 211   /* validity - not after */
 212   str = ptr;
 213   ptr = strchr(str, '#');
 214   if (ptr == NULLCP)
 215   {
 216     parse_error("End time not present",NULLCP);
 217     cert_free(result);
 218     return (struct certificate *) 0;
 219   }
 220   *ptr++ = '\0';
 221   result->valid.not_after = strdup(str);
 222
 223   /* subject */
 224   str = ptr;
 225   ptr = strchr(str, '#');
 226   if (ptr == NULLCP)
 227   {
 228     parse_error("Subject not present",NULLCP);
 229     cert_free(result);
 230     return (struct certificate *) 0;
 231   }
 232   *ptr++ = '\0';
 233   result->subject = ldap_str2dn(str);
 234
 235   /* public key info - algorithm id - oid */
 236   str = ptr;
 237   ptr = strchr(str, '#');
 238   if (ptr == NULLCP)
 239   {
 240     parse_error("public key info algid oid not present",NULLCP);
 241     cert_free(result);
 242     return (struct certificate *) 0;
 243   }
 244   *ptr++ = '\0';
 245   oid = name2oid(SkipSpace(str));
 246   if (oid == NULLOID)
 247   {
 248     free((char*)result);
 249     return (struct certificate *) 0;
 250   }
 251   result->key.alg.algorithm = oid;
 252
 253   /* public key info - algorithm id - parameters */
 254   str = ptr;
 255   ptr = strchr(str, '#');
 256   if (ptr == NULLCP)
 257   {
 258     parse_error("Parameters not present (SIGNED Value)",NULLCP);
 259     cert_free(result);
 260     return (struct certificate *) 0;
 261   }
 262   *ptr++ = '\0';
 263   ldap_str2alg(str, &(result->key.alg));
 264
 265   /* public key info - encrypted sign value */
 266   str = ptr;
 267   ptr = strchr(str, '#');
 268   if (ptr == NULLCP)
 269   {
 270     parse_error("Signature not present",NULLCP);
 271     cert_free(result);
 272     return (struct certificate *) 0;
 273   }
 274   *ptr++ = '\0';
 275   str2encrypted(str, &(result->key.value), &(result->key.n_bits));
 276
 277   /* encrypted sign value */
 278   str = ptr;
 279   str2encrypted(str, &(result->sig.encrypted), &(result->sig.n_bits));
 280
 281   return (result);
 282 }
 283
 284 void
 285 ldap_str2alg( char *str, struct alg_id *alg )
 286 {
 287   if ((str == NULLCP) || (*str == '\0'))
 288    {
 289      alg->asn = NULLPE;
 290      alg->p_type = ALG_PARM_ABSENT;
 291    }
 292   else if (strncmp(str,"{ASN}", 5) == 0)
 293     {
 294       alg->asn = asn2pe((char*)str+5);
 295       alg->p_type = ALG_PARM_UNKNOWN;
 296     }
 297   else if (strncmp(str, "NULL", 4) == 0)
 298     {
 299       alg->asn = asn2pe((char*)"0500");
 300       alg->p_type = ALG_PARM_UNKNOWN;
 301     }
 302   else
 303     {
 304       alg->asn=NULLPE;
 305       alg->p_type = ALG_PARM_NUMERIC;
 306       alg->un.numeric = atoi(str);
 307     }
 308 }
 309
 310 void
 311 certif_init( void )
 312 {
 313         sntx_table      *syntax_table;
 314
 315         if ((syntax_table = get_syntax_table(ldap_certif_syntax)) != NULL) {
 316                 syntax_table->s_print = (void *) ldap_certif_print;
 317                 syntax_table->s_parse = (void *) ldap_str2cert;
 318         } else
 319                 fprintf(stderr, "error getting sntx table in certif_init()\n");
 320 }