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

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