Source for javax.security.auth.x500.X500Principal

   1: /* X500Principal.java -- X.500 principal.
   2:    Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: 
  39: package javax.security.auth.x500;
  40: 
  41: import gnu.java.security.OID;
  42: import gnu.java.security.der.DER;
  43: import gnu.java.security.der.DERReader;
  44: import gnu.java.security.der.DERValue;
  45: 
  46: import java.io.ByteArrayInputStream;
  47: import java.io.EOFException;
  48: import java.io.IOException;
  49: import java.io.InputStream;
  50: import java.io.NotActiveException;
  51: import java.io.ObjectInputStream;
  52: import java.io.ObjectOutputStream;
  53: import java.io.Reader;
  54: import java.io.Serializable;
  55: import java.io.StringReader;
  56: 
  57: import java.security.Principal;
  58: 
  59: import java.util.ArrayList;
  60: import java.util.HashSet;
  61: import java.util.Iterator;
  62: import java.util.LinkedHashMap;
  63: import java.util.LinkedList;
  64: import java.util.List;
  65: import java.util.Locale;
  66: import java.util.Map;
  67: import java.util.Set;
  68: 
  69: public final class X500Principal implements Principal, Serializable
  70: {
  71:   private static final long serialVersionUID = -500463348111345721L;
  72: 
  73:   // Constants and fields.
  74:   // ------------------------------------------------------------------------
  75: 
  76:   public static final String CANONICAL = "CANONICAL";
  77:   public static final String RFC1779 = "RFC1779";
  78:   public static final String RFC2253 = "RFC2253";
  79: 
  80:   private static final OID CN         = new OID("2.5.4.3");
  81:   private static final OID C          = new OID("2.5.4.6");
  82:   private static final OID L          = new OID("2.5.4.7");
  83:   private static final OID ST         = new OID("2.5.4.8");
  84:   private static final OID STREET     = new OID("2.5.4.9");
  85:   private static final OID O          = new OID("2.5.4.10");
  86:   private static final OID OU         = new OID("2.5.4.11");
  87:   private static final OID DC         = new OID("0.9.2342.19200300.100.1.25");
  88:   private static final OID UID        = new OID("0.9.2342.19200300.100.1.1");
  89: 
  90:   private transient List components;
  91:   private transient Map currentRdn;
  92:   private transient boolean fixed;
  93:   private transient byte[] encoded;
  94: 
  95:   // Constructors.
  96:   // ------------------------------------------------------------------------
  97: 
  98:   private X500Principal()
  99:   {
 100:     components = new LinkedList();
 101:     currentRdn = new LinkedHashMap();
 102:     components.add (currentRdn);
 103:   }
 104: 
 105:   public X500Principal (String name)
 106:   {
 107:     this();
 108:     if (name == null)
 109:       throw new NullPointerException();
 110:     try
 111:       {
 112:         parseString (name);
 113:       }
 114:     catch (IOException ioe)
 115:       {
 116:         IllegalArgumentException iae = new IllegalArgumentException("malformed name");
 117:         iae.initCause (ioe);
 118:         throw iae;
 119:       }
 120:   }
 121: 
 122:   public X500Principal (byte[] encoded)
 123:   {
 124:     this(new ByteArrayInputStream (encoded));
 125:   }
 126: 
 127:   public X500Principal (InputStream encoded)
 128:   {
 129:     this();
 130:     try
 131:       {
 132:         parseDer (encoded);
 133:       }
 134:     catch (IOException ioe)
 135:       {
 136:         throw new IllegalArgumentException (ioe.toString());
 137:       }
 138:   }
 139: 
 140:   // Instance methods.
 141:   // ------------------------------------------------------------------------
 142: 
 143:   public int hashCode()
 144:   {
 145:     int result = size();
 146:     for (int i = 0; i < size(); ++i)
 147:       {
 148:         Map m = (Map) components.get(i);
 149:         for (Iterator it2 = m.entrySet().iterator(); it2.hasNext(); )
 150:           {
 151:             Map.Entry e = (Map.Entry) it2.next();
 152:             // We don't bother looking at the value of the entry.
 153:             result = result * 31 + ((OID) e.getKey()).hashCode();
 154:           }
 155:       }
 156:     return result;
 157:   }
 158: 
 159:   public boolean equals(Object o)
 160:   {
 161:     if (!(o instanceof X500Principal))
 162:       return false;
 163:     if (size() != ((X500Principal) o).size())
 164:       return false;
 165:     for (int i = 0; i < size(); i++)
 166:       {
 167:         Map m = (Map) components.get (i);
 168:         for (Iterator it2 = m.entrySet().iterator(); it2.hasNext(); )
 169:           {
 170:             Map.Entry e = (Map.Entry) it2.next();
 171:             OID oid = (OID) e.getKey();
 172:             String v1 = (String) e.getValue();
 173:             String v2 = ((X500Principal) o).getComponent (oid, i);
 174:             if (v2 == null)
 175:               return false;
 176:             if (!compressWS (v1).equalsIgnoreCase (compressWS (v2)))
 177:               return false;
 178:           }
 179:       }
 180:     return true;
 181:   }
 182: 
 183:   public byte[] getEncoded()
 184:   {
 185:     if (encoded == null)
 186:       encodeDer();
 187:     return (byte[]) encoded.clone();
 188:   }
 189: 
 190:   public String getName()
 191:   {
 192:     return getName (RFC2253);
 193:   }
 194: 
 195:   public String getName (final String format)
 196:   {
 197:     boolean rfc2253 = RFC2253.equalsIgnoreCase (format) ||
 198:       CANONICAL.equalsIgnoreCase (format);
 199:     boolean rfc1779 = RFC1779.equalsIgnoreCase (format);
 200:     boolean canon   = CANONICAL.equalsIgnoreCase (format);
 201:     if (! (rfc2253 || rfc1779 || canon))
 202:       throw new IllegalArgumentException ("unsupported format " + format);
 203:     StringBuffer str = new StringBuffer();
 204:     for (Iterator it = components.iterator(); it.hasNext(); )
 205:       {
 206:         Map m = (Map) it.next();
 207:         for (Iterator it2 = m.entrySet().iterator(); it2.hasNext(); )
 208:           {
 209:             Map.Entry entry = (Map.Entry) it2.next();
 210:             OID oid = (OID) entry.getKey();
 211:             String value = (String) entry.getValue();
 212:             if (oid.equals (CN))
 213:               str.append ("CN");
 214:             else if (oid.equals (C))
 215:               str.append ("C");
 216:             else if (oid.equals (L))
 217:               str.append ("L");
 218:             else if (oid.equals (ST))
 219:               str.append ("ST");
 220:             else if (oid.equals (STREET))
 221:               str.append ("STREET");
 222:             else if (oid.equals (O))
 223:               str.append ("O");
 224:             else if (oid.equals (OU))
 225:               str.append ("OU");
 226:             else if (oid.equals (DC) && rfc2253)
 227:               str.append ("DC");
 228:             else if (oid.equals (UID) && rfc2253)
 229:               str.append ("UID");
 230:             else
 231:               str.append (oid.toString());
 232:             str.append('=');
 233:             str.append(value);
 234:             if (it2.hasNext())
 235:               str.append('+');
 236:           }
 237:         if (it.hasNext())
 238:           str.append(',');
 239:       }
 240:     if (canon)
 241:       return str.toString().toUpperCase (Locale.US).toLowerCase (Locale.US);
 242:     return str.toString();
 243:   }
 244: 
 245:   public String toString()
 246:   {
 247:     return getName (RFC2253);
 248:   }
 249: 
 250:   // Serialization methods.
 251:   // ------------------------------------------------------------------------
 252: 
 253:   private void writeObject (ObjectOutputStream out) throws IOException
 254:   {
 255:     if (encoded != null)
 256:       encodeDer();
 257:     out.writeObject (encoded);
 258:   }
 259: 
 260:   private void readObject (ObjectInputStream in)
 261:     throws IOException, NotActiveException, ClassNotFoundException
 262:   {
 263:     byte[] buf = (byte[]) in.readObject();
 264:     parseDer (new ByteArrayInputStream (buf));
 265:   }
 266: 
 267:   // Own methods.
 268:   // -------------------------------------------------------------------------
 269: 
 270:   private int size()
 271:   {
 272:     return components.size();
 273:   }
 274: 
 275:   private String getComponent(OID oid, int rdn)
 276:   {
 277:     if (rdn >= size())
 278:       return null;
 279:     return (String) ((Map) components.get (rdn)).get (oid);
 280:   }
 281: 
 282:   private void encodeDer()
 283:   {
 284:     ArrayList name = new ArrayList(components.size());
 285:     for (Iterator it = components.iterator(); it.hasNext(); )
 286:       {
 287:         Map m = (Map) it.next();
 288:         if (m.isEmpty())
 289:           continue;
 290:         Set rdn = new HashSet();
 291:         for (Iterator it2 = m.entrySet().iterator(); it2.hasNext(); )
 292:           {
 293:             Map.Entry e = (Map.Entry) it2.next();
 294:             ArrayList atav = new ArrayList(2);
 295:             atav.add(new DERValue(DER.OBJECT_IDENTIFIER, e.getKey()));
 296:             atav.add(new DERValue(DER.UTF8_STRING, e.getValue()));
 297:             rdn.add(new DERValue(DER.SEQUENCE|DER.CONSTRUCTED, atav));
 298:           }
 299:         name.add(new DERValue(DER.SET|DER.CONSTRUCTED, rdn));
 300:       }
 301:     DERValue val = new DERValue(DER.SEQUENCE|DER.CONSTRUCTED, name);
 302:     encoded = val.getEncoded();
 303:   }
 304: 
 305:   private int sep;
 306: 
 307:   private void parseString(String str) throws IOException
 308:   {
 309:     Reader in = new StringReader(str);
 310:     while (true)
 311:       {
 312:         String key = readAttributeType(in);
 313:         if (key == null)
 314:           break;
 315:         String value = readAttributeValue(in);
 316:         putComponent(key, value);
 317:         if (sep == ',')
 318:           newRelativeDistinguishedName();
 319:         if (sep == -1)
 320:           break;
 321:       }
 322:   }
 323: 
 324:   private String readAttributeType(Reader in) throws IOException
 325:   {
 326:     StringBuffer buf = new StringBuffer();
 327:     int ch;
 328:     while ((ch = in.read()) != '=')
 329:       {
 330:         if (ch == -1)
 331:           {
 332:             if (buf.length() > 0)
 333:               throw new EOFException("partial name read: " + buf);
 334:             return null;
 335:           }
 336:         if (ch > 127)
 337:           throw new IOException("Invalid char: " + (char) ch);
 338:         if (Character.isLetterOrDigit((char) ch) || ch == '-' || ch == '.')
 339:           buf.append((char) ch);
 340:         else
 341:           throw new IOException("Invalid char: " + (char) ch);
 342:       }
 343:     return buf.toString();
 344:   }
 345: 
 346:   private String readAttributeValue(Reader in) throws IOException
 347:   {
 348:     StringBuffer buf = new StringBuffer();
 349:     int ch = in.read();
 350:     if (ch == '#')
 351:       {
 352:         while (true)
 353:           {
 354:             ch = in.read();
 355:             if (('a' <= ch && ch <= 'f') || ('A' <= ch && ch <= 'F')
 356:                 || Character.isDigit((char) ch))
 357:               buf.append((char) ch);
 358:             else if (ch == '+' || ch == ',')
 359:               {
 360:                 sep = ch;
 361:                 String hex = buf.toString();
 362:                 return new String(toByteArray(hex));
 363:               }
 364:             else
 365:               throw new IOException("illegal character: " + (char) ch);
 366:           }
 367:       }
 368:     else if (ch == '"')
 369:       {
 370:         while (true)
 371:           {
 372:             ch = in.read();
 373:             if (ch == '"')
 374:               break;
 375:             else if (ch == '\\')
 376:               {
 377:                 ch = in.read();
 378:                 if (ch == -1)
 379:                   throw new EOFException();
 380:                 if (('a' <= ch && ch <= 'f') || ('A' <= ch && ch <= 'F')
 381:                     || Character.isDigit((char) ch))
 382:                   {
 383:                     int i = Character.digit((char) ch, 16) << 4;
 384:                     ch = in.read();
 385:                     if (!(('a' <= ch && ch <= 'f') || ('A' <= ch && ch <= 'F')
 386:                           || Character.isDigit((char) ch)))
 387:                       throw new IOException("illegal hex char");
 388:                     i |= Character.digit((char) ch, 16);
 389:                     buf.append((char) i);
 390:                   }
 391:                 else
 392:                   buf.append((char) ch);
 393:               }
 394:             else
 395:               buf.append((char) ch);
 396:           }
 397:         sep = in.read();
 398:         if (sep != '+' && sep != ',')
 399:           throw new IOException("illegal character: " + (char) ch);
 400:         return buf.toString();
 401:       }
 402:     else
 403:       {
 404:         while (true)
 405:           {
 406:             switch (ch)
 407:               {
 408:               case '+':
 409:               case ',':
 410:                 sep = ch;
 411:                 return buf.toString();
 412:               case '\\':
 413:                 ch = in.read();
 414:                 if (ch == -1)
 415:                   throw new EOFException();
 416:                 if (('a' <= ch && ch <= 'f') || ('A' <= ch && ch <= 'F')
 417:                     || Character.isDigit((char) ch))
 418:                   {
 419:                     int i = Character.digit((char) ch, 16) << 4;
 420:                     ch = in.read();
 421:                     if (!(('a' <= ch && ch <= 'f') || ('A' <= ch && ch <= 'F')
 422:                           || Character.isDigit((char) ch)))
 423:                       throw new IOException("illegal hex char");
 424:                     i |= Character.digit((char) ch, 16);
 425:                     buf.append((char) i);
 426:                   }
 427:                 else
 428:                   buf.append((char) ch);
 429:                 break;
 430:               case '=':
 431:               case '<':
 432:               case '>':
 433:               case '#':
 434:               case ';':
 435:                 throw new IOException("illegal character: " + (char) ch);
 436:               case -1:
 437:                 sep = -1;
 438:                 return buf.toString ();
 439:               default:
 440:                 buf.append((char) ch);
 441:               }
 442:             ch = in.read ();
 443:           }
 444:       }
 445:   }
 446: 
 447:   private void parseDer (InputStream encoded) throws IOException
 448:   {
 449:     DERReader der = new DERReader (encoded);
 450:     DERValue name = der.read();
 451:     if (!name.isConstructed())
 452:       throw new IOException ("malformed Name");
 453:     this.encoded = name.getEncoded();
 454:     int len = 0;
 455:     while (len < name.getLength())
 456:       {
 457:         DERValue rdn = der.read();
 458:         if (!rdn.isConstructed())
 459:           throw new IOException ("badly formed RDNSequence");
 460:         int len2 = 0;
 461:         while (len2 < rdn.getLength())
 462:           {
 463:             DERValue atav = der.read();
 464:             if (!atav.isConstructed())
 465:               throw new IOException ("badly formed AttributeTypeAndValue");
 466:             DERValue val = der.read();
 467:             if (val.getTag() != DER.OBJECT_IDENTIFIER)
 468:               throw new IOException ("badly formed AttributeTypeAndValue");
 469:             OID oid = (OID) val.getValue();
 470:             val = der.read();
 471:             if (!(val.getValue() instanceof String))
 472:               throw new IOException ("badly formed AttributeTypeAndValue");
 473:             String value = (String) val.getValue();
 474:             putComponent(oid, value);
 475:             len2 += atav.getEncodedLength();
 476:           }
 477:         len += rdn.getEncodedLength();
 478:         if (len < name.getLength())
 479:           newRelativeDistinguishedName();
 480:       }
 481:   }
 482: 
 483:   private void newRelativeDistinguishedName()
 484:   {
 485:     currentRdn = new LinkedHashMap();
 486:     components.add(currentRdn);
 487:   }
 488: 
 489:   private void putComponent(OID oid, String value)
 490:   {
 491:     currentRdn.put(oid, value);
 492:   }
 493: 
 494:   private void putComponent(String name, String value)
 495:   {
 496:     name = name.trim().toLowerCase();
 497:     if (name.equals("cn"))
 498:       putComponent(CN, value);
 499:     else if (name.equals("c"))
 500:       putComponent(C, value);
 501:     else if (name.equals("l"))
 502:       putComponent(L, value);
 503:     else if (name.equals("street"))
 504:       putComponent(STREET, value);
 505:     else if (name.equals("st"))
 506:       putComponent(ST, value);
 507:     else if (name.equals ("o"))
 508:       putComponent (O, value);
 509:     else if (name.equals ("ou"))
 510:       putComponent (OU, value);
 511:     else if (name.equals("dc"))
 512:       putComponent(DC, value);
 513:     else if (name.equals("uid"))
 514:       putComponent(UID, value);
 515:     else
 516:       putComponent(new OID(name), value);
 517:   }
 518: 
 519:   private static String compressWS(String str)
 520:   {
 521:     StringBuffer buf = new StringBuffer();
 522:     char lastChar = 0;
 523:     for (int i = 0; i < str.length(); i++)
 524:       {
 525:         char c = str.charAt(i);
 526:         if (Character.isWhitespace(c))
 527:           {
 528:             if (!Character.isWhitespace(lastChar))
 529:               buf.append(' ');
 530:           }
 531:         else
 532:           buf.append(c);
 533:         lastChar = c;
 534:       }
 535:     return buf.toString().trim();
 536:   }
 537: 
 538:   private static byte[] toByteArray (String str)
 539:   {
 540:     int limit = str.length();
 541:     byte[] result = new byte[((limit + 1) / 2)];
 542:     int i = 0, j = 0;
 543:     if ((limit % 2) == 1)
 544:       {
 545:         result[j++] = (byte) Character.digit (str.charAt(i++), 16);
 546:       }
 547:     while (i < limit)
 548:       {
 549:         result[j  ]  = (byte) (Character.digit (str.charAt(i++), 16) << 4);
 550:         result[j++] |= (byte)  Character.digit (str.charAt(i++), 16);
 551:       }
 552:     return result;
 553:   }
 554: }