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