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