001 /*
002 * CDDL HEADER START
003 *
004 * The contents of this file are subject to the terms of the
005 * Common Development and Distribution License, Version 1.0 only
006 * (the "License"). You may not use this file except in compliance
007 * with the License.
008 *
009 * You can obtain a copy of the license at
010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE
011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
012 * See the License for the specific language governing permissions
013 * and limitations under the License.
014 *
015 * When distributing Covered Code, include this CDDL HEADER in each
016 * file and include the License file at
017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
018 * add the following below this CDDL HEADER, with the fields enclosed
019 * by brackets "[]" replaced with your own identifying information:
020 * Portions Copyright [yyyy] [name of copyright owner]
021 *
022 * CDDL HEADER END
023 *
024 *
025 * Copyright 2006-2008 Sun Microsystems, Inc.
026 */
027 package org.opends.server.tools;
028 import org.opends.messages.Message;
029
030
031
032 import java.io.OutputStream;
033 import java.io.PrintStream;
034 import java.util.ArrayList;
035 import java.util.Arrays;
036 import java.util.concurrent.ConcurrentHashMap;
037
038 import org.opends.server.api.PasswordStorageScheme;
039 import org.opends.server.config.ConfigException;
040 import org.opends.server.core.CoreConfigManager;
041 import org.opends.server.core.DirectoryServer;
042 import org.opends.server.core.PasswordStorageSchemeConfigManager;
043 import org.opends.server.extensions.ConfigFileHandler;
044 import org.opends.server.protocols.asn1.ASN1OctetString;
045 import org.opends.server.protocols.ldap.LDAPResultCode;
046 import org.opends.server.schema.AuthPasswordSyntax;
047 import org.opends.server.schema.UserPasswordSyntax;
048 import org.opends.server.types.ByteString;
049 import org.opends.server.types.DirectoryException;
050 import org.opends.server.types.InitializationException;
051 import org.opends.server.types.NullOutputStream;
052 import org.opends.server.util.args.ArgumentException;
053 import org.opends.server.util.args.ArgumentParser;
054 import org.opends.server.util.args.BooleanArgument;
055 import org.opends.server.util.args.FileBasedArgument;
056 import org.opends.server.util.args.StringArgument;
057
058 import static org.opends.messages.ToolMessages.*;
059 import static org.opends.server.util.ServerConstants.*;
060 import static org.opends.server.util.StaticUtils.*;
061 import static org.opends.server.tools.ToolConstants.*;
062
063
064
065 /**
066 * This program provides a utility that may be used to interact with the
067 * password storage schemes defined in the Directory Server. In particular,
068 * it can encode a clear-text password using a specified scheme, and it can also
069 * determine whether a given encoded password is the encoded representation of a
070 * given clear-text password. Alternately, it can be used to obtain a list of
071 * the available password storage scheme names.
072 */
073 public class EncodePassword
074 {
075 /**
076 * Processes the command-line arguments and performs the requested action.
077 *
078 * @param args The command-line arguments provided to this program.
079 */
080 public static void main(String[] args)
081 {
082 int returnCode = encodePassword(args, true, System.out, System.err);
083 if (returnCode != 0)
084 {
085 System.exit(filterExitCode(returnCode));
086 }
087 }
088
089
090
091 /**
092 * Processes the command-line arguments and performs the requested action.
093 *
094 * @param args The command-line arguments provided to this program.
095 *
096 * @return An integer value that indicates whether processing was successful.
097 */
098 public static int encodePassword(String[] args)
099 {
100 return encodePassword(args, true, System.out, System.err);
101 }
102
103
104
105 /**
106 * Processes the command-line arguments and performs the requested action.
107 *
108 * @param args The command-line arguments provided to this
109 * program.
110 * @param initializeServer Indicates whether to initialize the server.
111 * @param outStream The output stream to use for standard output, or
112 * <CODE>null</CODE> if standard output is not
113 * needed.
114 * @param errStream The output stream to use for standard error, or
115 * <CODE>null</CODE> if standard error is not
116 * needed.
117 *
118 * @return An integer value that indicates whether processing was successful.
119 */
120 public static int encodePassword(String[] args, boolean initializeServer,
121 OutputStream outStream,
122 OutputStream errStream)
123 {
124 PrintStream out;
125 if (outStream == null)
126 {
127 out = NullOutputStream.printStream();
128 }
129 else
130 {
131 out = new PrintStream(outStream);
132 }
133
134 PrintStream err;
135 if (errStream == null)
136 {
137 err = NullOutputStream.printStream();
138 }
139 else
140 {
141 err = new PrintStream(errStream);
142 }
143
144 // Define the command-line arguments that may be used with this program.
145 BooleanArgument authPasswordSyntax = null;
146 BooleanArgument useCompareResultCode = null;
147 BooleanArgument listSchemes = null;
148 BooleanArgument showUsage = null;
149 StringArgument clearPassword = null;
150 FileBasedArgument clearPasswordFile = null;
151 StringArgument encodedPassword = null;
152 FileBasedArgument encodedPasswordFile = null;
153 StringArgument configClass = null;
154 StringArgument configFile = null;
155 StringArgument schemeName = null;
156
157
158 // Create the command-line argument parser for use with this program.
159 Message toolDescription = INFO_ENCPW_TOOL_DESCRIPTION.get();
160 ArgumentParser argParser =
161 new ArgumentParser("org.opends.server.tools.EncodePassword",
162 toolDescription, false);
163
164
165 // Initialize all the command-line argument types and register them with the
166 // parser.
167 try
168 {
169 listSchemes = new BooleanArgument(
170 "listschemes", 'l', "listSchemes",
171 INFO_ENCPW_DESCRIPTION_LISTSCHEMES.get());
172 argParser.addArgument(listSchemes);
173
174
175 clearPassword = new StringArgument("clearpw", 'c', "clearPassword", false,
176 false, true, INFO_CLEAR_PWD.get(),
177 null, null,
178 INFO_ENCPW_DESCRIPTION_CLEAR_PW.get());
179 argParser.addArgument(clearPassword);
180
181
182 clearPasswordFile =
183 new FileBasedArgument("clearpwfile", 'f', "clearPasswordFile", false,
184 false, INFO_FILE_PLACEHOLDER.get(), null, null,
185 INFO_ENCPW_DESCRIPTION_CLEAR_PW_FILE.get());
186 argParser.addArgument(clearPasswordFile);
187
188
189 encodedPassword = new StringArgument(
190 "encodedpw", 'e', "encodedPassword",
191 false, false, true, INFO_ENCODED_PWD_PLACEHOLDER.get(),
192 null, null,
193 INFO_ENCPW_DESCRIPTION_ENCODED_PW.get());
194 argParser.addArgument(encodedPassword);
195
196
197 encodedPasswordFile =
198 new FileBasedArgument("encodedpwfile", 'E', "encodedPasswordFile",
199 false, false, INFO_FILE_PLACEHOLDER.get(),
200 null, null,
201 INFO_ENCPW_DESCRIPTION_ENCODED_PW_FILE.get());
202 argParser.addArgument(encodedPasswordFile);
203
204
205 configClass = new StringArgument("configclass", OPTION_SHORT_CONFIG_CLASS,
206 OPTION_LONG_CONFIG_CLASS,
207 true, false, true,
208 INFO_CONFIGCLASS_PLACEHOLDER.get(),
209 ConfigFileHandler.class.getName(), null,
210 INFO_DESCRIPTION_CONFIG_CLASS.get());
211 configClass.setHidden(true);
212 argParser.addArgument(configClass);
213
214
215 configFile = new StringArgument("configfile", 'F', "configFile",
216 true, false, true,
217 INFO_CONFIGFILE_PLACEHOLDER.get(), null,
218 null,
219 INFO_DESCRIPTION_CONFIG_FILE.get());
220 configFile.setHidden(true);
221 argParser.addArgument(configFile);
222
223
224 schemeName = new StringArgument("scheme", 's', "storageScheme", false,
225 false, true,
226 INFO_STORAGE_SCHEME_PLACEHOLDER.get(),
227 null, null,
228 INFO_ENCPW_DESCRIPTION_SCHEME.get());
229 argParser.addArgument(schemeName);
230
231
232 authPasswordSyntax = new BooleanArgument(
233 "authpasswordsyntax", 'a',
234 "authPasswordSyntax",
235 INFO_ENCPW_DESCRIPTION_AUTHPW.get());
236 argParser.addArgument(authPasswordSyntax);
237
238
239 useCompareResultCode =
240 new BooleanArgument("usecompareresultcode", 'r',
241 "useCompareResultCode",
242 INFO_ENCPW_DESCRIPTION_USE_COMPARE_RESULT.get());
243 argParser.addArgument(useCompareResultCode);
244
245
246 showUsage = new BooleanArgument("usage", OPTION_SHORT_HELP,
247 OPTION_LONG_HELP,
248 INFO_DESCRIPTION_USAGE.get());
249 argParser.addArgument(showUsage);
250 argParser.setUsageArgument(showUsage, out);
251 }
252 catch (ArgumentException ae)
253 {
254 Message message = ERR_CANNOT_INITIALIZE_ARGS.get(ae.getMessage());
255
256 err.println(wrapText(message, MAX_LINE_WIDTH));
257 return 1;
258 }
259
260
261 // Parse the command-line arguments provided to this program.
262 try
263 {
264 argParser.parseArguments(args);
265 }
266 catch (ArgumentException ae)
267 {
268 Message message = ERR_ERROR_PARSING_ARGS.get(ae.getMessage());
269
270 err.println(wrapText(message, MAX_LINE_WIDTH));
271 err.println(argParser.getUsage());
272 return 1;
273 }
274
275
276 // If we should just display usage or version information,
277 // then we've already done it so just return without doing anything else.
278 if (argParser.usageOrVersionDisplayed())
279 {
280 return 0;
281 }
282
283
284 // Check for conflicting arguments.
285 if (clearPassword.isPresent() && clearPasswordFile.isPresent())
286 {
287 Message message =
288 ERR_TOOL_CONFLICTING_ARGS.get(clearPassword.getLongIdentifier(),
289 clearPasswordFile.getLongIdentifier());
290 err.println(wrapText(message, MAX_LINE_WIDTH));
291 return 1;
292 }
293
294 if (encodedPassword.isPresent() && encodedPasswordFile.isPresent())
295 {
296 Message message =
297 ERR_TOOL_CONFLICTING_ARGS.get(encodedPassword.getLongIdentifier(),
298 encodedPasswordFile.getLongIdentifier());
299 err.println(wrapText(message, MAX_LINE_WIDTH));
300 return 1;
301 }
302
303
304 // If we are not going to just list the storage schemes, then the clear-text
305 // password must have been provided. If we're going to encode a password,
306 // then the scheme must have also been provided.
307 ASN1OctetString clearPW = null;
308 if (! listSchemes.isPresent())
309 {
310 if (clearPassword.hasValue())
311 {
312 clearPW = new ASN1OctetString(clearPassword.getValue());
313 }
314 else if (clearPasswordFile.hasValue())
315 {
316 clearPW = new ASN1OctetString(clearPasswordFile.getValue());
317 }
318 else
319 {
320 Message message =
321 ERR_ENCPW_NO_CLEAR_PW.get(clearPassword.getLongIdentifier(),
322 clearPasswordFile.getLongIdentifier());
323 err.println(wrapText(message, MAX_LINE_WIDTH));
324 err.println(argParser.getUsage());
325 return 1;
326 }
327
328 if ((! encodedPassword.isPresent()) && (! encodedPasswordFile.isPresent())
329 && (! schemeName.isPresent()))
330 {
331 Message message =
332 ERR_ENCPW_NO_SCHEME.get(schemeName.getLongIdentifier());
333 err.println(wrapText(message, MAX_LINE_WIDTH));
334 err.println(argParser.getUsage());
335 return 1;
336 }
337 }
338
339
340 // Determine whether we're encoding the clear-text password or comparing it
341 // against an already-encoded password.
342 boolean compareMode;
343 ByteString encodedPW = null;
344 if (encodedPassword.hasValue())
345 {
346 compareMode = true;
347 encodedPW = new ASN1OctetString(encodedPassword.getValue());
348 }
349 else if (encodedPasswordFile.hasValue())
350 {
351 compareMode = true;
352 encodedPW = new ASN1OctetString(encodedPasswordFile.getValue());
353 }
354 else
355 {
356 compareMode = false;
357 }
358
359
360 // Perform the initial bootstrap of the Directory Server and process the
361 // configuration.
362 DirectoryServer directoryServer = DirectoryServer.getInstance();
363
364 if (initializeServer)
365 {
366 try
367 {
368 directoryServer.bootstrapClient();
369 directoryServer.initializeJMX();
370 }
371 catch (Exception e)
372 {
373 Message message =
374 ERR_SERVER_BOOTSTRAP_ERROR.get(getExceptionMessage(e));
375 err.println(wrapText(message, MAX_LINE_WIDTH));
376 return 1;
377 }
378
379 try
380 {
381 directoryServer.initializeConfiguration(configClass.getValue(),
382 configFile.getValue());
383 }
384 catch (InitializationException ie)
385 {
386 Message message = ERR_CANNOT_LOAD_CONFIG.get(ie.getMessage());
387 err.println(wrapText(message, MAX_LINE_WIDTH));
388 return 1;
389 }
390 catch (Exception e)
391 {
392 Message message = ERR_CANNOT_LOAD_CONFIG.get(getExceptionMessage(e));
393 err.println(wrapText(message, MAX_LINE_WIDTH));
394 return 1;
395 }
396
397
398
399 // Initialize the Directory Server schema elements.
400 try
401 {
402 directoryServer.initializeSchema();
403 }
404 catch (ConfigException ce)
405 {
406 Message message = ERR_CANNOT_LOAD_SCHEMA.get(ce.getMessage());
407 err.println(wrapText(message, MAX_LINE_WIDTH));
408 return 1;
409 }
410 catch (InitializationException ie)
411 {
412 Message message = ERR_CANNOT_LOAD_SCHEMA.get(ie.getMessage());
413 err.println(wrapText(message, MAX_LINE_WIDTH));
414 return 1;
415 }
416 catch (Exception e)
417 {
418 Message message = ERR_CANNOT_LOAD_SCHEMA.get(getExceptionMessage(e));
419 err.println(wrapText(message, MAX_LINE_WIDTH));
420 return 1;
421 }
422
423
424 // Initialize the Directory Server core configuration.
425 try
426 {
427 CoreConfigManager coreConfigManager = new CoreConfigManager();
428 coreConfigManager.initializeCoreConfig();
429 }
430 catch (ConfigException ce)
431 {
432 Message message =
433 ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(ce.getMessage());
434 err.println(wrapText(message, MAX_LINE_WIDTH));
435 return 1;
436 }
437 catch (InitializationException ie)
438 {
439 Message message =
440 ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(ie.getMessage());
441 err.println(wrapText(message, MAX_LINE_WIDTH));
442 return 1;
443 }
444 catch (Exception e)
445 {
446 Message message =
447 ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(getExceptionMessage(e));
448 err.println(wrapText(message, MAX_LINE_WIDTH));
449 return 1;
450 }
451
452
453 // Initialize the password storage schemes.
454 try
455 {
456 PasswordStorageSchemeConfigManager storageSchemeConfigManager =
457 new PasswordStorageSchemeConfigManager();
458 storageSchemeConfigManager.initializePasswordStorageSchemes();
459 }
460 catch (ConfigException ce)
461 {
462 Message message =
463 ERR_ENCPW_CANNOT_INITIALIZE_STORAGE_SCHEMES.get(
464 ce.getMessage());
465 err.println(wrapText(message, MAX_LINE_WIDTH));
466 return 1;
467 }
468 catch (InitializationException ie)
469 {
470 Message message = ERR_ENCPW_CANNOT_INITIALIZE_STORAGE_SCHEMES.get(
471 ie.getMessage());
472 err.println(wrapText(message, MAX_LINE_WIDTH));
473 return 1;
474 }
475 catch (Exception e)
476 {
477 Message message = ERR_ENCPW_CANNOT_INITIALIZE_STORAGE_SCHEMES.get(
478 getExceptionMessage(e));
479 err.println(wrapText(message, MAX_LINE_WIDTH));
480 return 1;
481 }
482 }
483
484
485 // If we are only trying to list the available schemes, then do so and exit.
486 if (listSchemes.isPresent())
487 {
488 if (authPasswordSyntax.isPresent())
489 {
490 ConcurrentHashMap<String,PasswordStorageScheme> storageSchemes =
491 DirectoryServer.getAuthPasswordStorageSchemes();
492 if (storageSchemes.isEmpty())
493 {
494 Message message = ERR_ENCPW_NO_STORAGE_SCHEMES.get();
495 err.println(wrapText(message, MAX_LINE_WIDTH));
496 }
497 else
498 {
499 int size = storageSchemes.size();
500
501 ArrayList<String> nameList = new ArrayList<String>(size);
502 for (PasswordStorageScheme s : storageSchemes.values())
503 {
504 nameList.add(s.getAuthPasswordSchemeName());
505 }
506
507 String[] nameArray = new String[size];
508 nameList.toArray(nameArray);
509 Arrays.sort(nameArray);
510
511 for (String storageSchemeName : nameArray)
512 {
513 out.println(storageSchemeName);
514 }
515 }
516
517 return 0;
518 }
519 else
520 {
521 ConcurrentHashMap<String,PasswordStorageScheme> storageSchemes =
522 DirectoryServer.getPasswordStorageSchemes();
523 if (storageSchemes.isEmpty())
524 {
525 Message message = ERR_ENCPW_NO_STORAGE_SCHEMES.get();
526 err.println(wrapText(message, MAX_LINE_WIDTH));
527 }
528 else
529 {
530 int size = storageSchemes.size();
531
532 ArrayList<String> nameList = new ArrayList<String>(size);
533 for (PasswordStorageScheme s : storageSchemes.values())
534 {
535 nameList.add(s.getStorageSchemeName());
536 }
537
538 String[] nameArray = new String[size];
539 nameList.toArray(nameArray);
540 Arrays.sort(nameArray);
541
542 for (String storageSchemeName : nameArray)
543 {
544 out.println(storageSchemeName);
545 }
546 }
547
548 return 0;
549 }
550 }
551
552
553 // Either encode the clear-text password using the provided scheme, or
554 // compare the clear-text password against the encoded password.
555 if (compareMode)
556 {
557 // Check to see if the provided password value was encoded. If so, then
558 // break it down into its component parts and use that to perform the
559 // comparison. Otherwise, the user must have provided the storage scheme.
560 if (authPasswordSyntax.isPresent())
561 {
562 String scheme;
563 String authInfo;
564 String authValue;
565
566 try
567 {
568 StringBuilder[] authPWElements =
569 AuthPasswordSyntax.decodeAuthPassword(encodedPW.stringValue());
570 scheme = authPWElements[0].toString();
571 authInfo = authPWElements[1].toString();
572 authValue = authPWElements[2].toString();
573 }
574 catch (DirectoryException de)
575 {
576 Message message = ERR_ENCPW_INVALID_ENCODED_AUTHPW.get(
577 de.getMessageObject());
578 err.println(wrapText(message, MAX_LINE_WIDTH));
579 return 1;
580 }
581 catch (Exception e)
582 {
583 Message message = ERR_ENCPW_INVALID_ENCODED_AUTHPW.get(
584 String.valueOf(e));
585 err.println(wrapText(message, MAX_LINE_WIDTH));
586 return 1;
587 }
588
589 PasswordStorageScheme storageScheme =
590 DirectoryServer.getAuthPasswordStorageScheme(scheme);
591 if (storageScheme == null)
592 {
593 Message message = ERR_ENCPW_NO_SUCH_AUTH_SCHEME.get(
594 scheme);
595 err.println(wrapText(message, MAX_LINE_WIDTH));
596 return 1;
597 }
598
599 if (storageScheme.authPasswordMatches(clearPW, authInfo, authValue))
600 {
601 Message message = INFO_ENCPW_PASSWORDS_MATCH.get();
602 out.println(message);
603
604 if (useCompareResultCode.isPresent())
605 {
606 return LDAPResultCode.COMPARE_TRUE;
607 }
608 else
609 {
610 return 0;
611 }
612 }
613 else
614 {
615 Message message = INFO_ENCPW_PASSWORDS_DO_NOT_MATCH.get();
616 out.println(message);
617
618 if (useCompareResultCode.isPresent())
619 {
620 return LDAPResultCode.COMPARE_FALSE;
621 }
622 else
623 {
624 return 0;
625 }
626 }
627 }
628 else
629 {
630 PasswordStorageScheme storageScheme;
631 String encodedPWString;
632
633 if (UserPasswordSyntax.isEncoded(encodedPW))
634 {
635 try
636 {
637 String[] userPWElements =
638 UserPasswordSyntax.decodeUserPassword(encodedPW.stringValue());
639 encodedPWString = userPWElements[1];
640
641 storageScheme =
642 DirectoryServer.getPasswordStorageScheme(userPWElements[0]);
643 if (storageScheme == null)
644 {
645 Message message = ERR_ENCPW_NO_SUCH_SCHEME.get(userPWElements[0]);
646 err.println(wrapText(message, MAX_LINE_WIDTH));
647 return 1;
648 }
649 }
650 catch (DirectoryException de)
651 {
652 Message message = ERR_ENCPW_INVALID_ENCODED_USERPW.get(
653 de.getMessageObject());
654 err.println(wrapText(message, MAX_LINE_WIDTH));
655 return 1;
656 }
657 catch (Exception e)
658 {
659 Message message = ERR_ENCPW_INVALID_ENCODED_USERPW.get(
660 String.valueOf(e));
661 err.println(wrapText(message, MAX_LINE_WIDTH));
662 return 1;
663 }
664 }
665 else
666 {
667 if (! schemeName.isPresent())
668 {
669 Message message = ERR_ENCPW_NO_SCHEME.get(
670 schemeName.getLongIdentifier());
671 err.println(wrapText(message, MAX_LINE_WIDTH));
672 return 1;
673 }
674
675 encodedPWString = encodedPW.toString();
676
677 String scheme = toLowerCase(schemeName.getValue());
678 storageScheme = directoryServer.getPasswordStorageScheme(scheme);
679 if (storageScheme == null)
680 {
681 Message message = ERR_ENCPW_NO_SUCH_SCHEME.get(scheme);
682 err.println(wrapText(message, MAX_LINE_WIDTH));
683 return 1;
684 }
685 }
686
687 if (storageScheme.passwordMatches(clearPW,
688 new ASN1OctetString(encodedPWString)))
689 {
690 Message message = INFO_ENCPW_PASSWORDS_MATCH.get();
691 out.println(message);
692
693 if (useCompareResultCode.isPresent())
694 {
695 return LDAPResultCode.COMPARE_TRUE;
696 }
697 else
698 {
699 return 0;
700 }
701 }
702 else
703 {
704 Message message = INFO_ENCPW_PASSWORDS_DO_NOT_MATCH.get();
705 out.println(message);
706
707 if (useCompareResultCode.isPresent())
708 {
709 return LDAPResultCode.COMPARE_FALSE;
710 }
711 else
712 {
713 return 0;
714 }
715 }
716 }
717 }
718 else
719 {
720 // Try to get a reference to the requested password storage scheme.
721 PasswordStorageScheme storageScheme;
722 if (authPasswordSyntax.isPresent())
723 {
724 String scheme = schemeName.getValue();
725 storageScheme = DirectoryServer.getAuthPasswordStorageScheme(scheme);
726 if (storageScheme == null)
727 {
728 Message message = ERR_ENCPW_NO_SUCH_AUTH_SCHEME.get(scheme);
729 err.println(wrapText(message, MAX_LINE_WIDTH));
730 return 1;
731 }
732 }
733 else
734 {
735 String scheme = toLowerCase(schemeName.getValue());
736 storageScheme = DirectoryServer.getPasswordStorageScheme(scheme);
737 if (storageScheme == null)
738 {
739 Message message = ERR_ENCPW_NO_SUCH_SCHEME.get(scheme);
740 err.println(wrapText(message, MAX_LINE_WIDTH));
741 return 1;
742 }
743 }
744
745 if (authPasswordSyntax.isPresent())
746 {
747 try
748 {
749 encodedPW = storageScheme.encodeAuthPassword(clearPW);
750
751 Message message = ERR_ENCPW_ENCODED_PASSWORD.get(
752 encodedPW.stringValue());
753 out.println(message);
754 }
755 catch (DirectoryException de)
756 {
757 Message message = ERR_ENCPW_CANNOT_ENCODE.get(de.getMessageObject());
758 err.println(wrapText(message, MAX_LINE_WIDTH));
759 return 1;
760 }
761 catch (Exception e)
762 {
763 Message message = ERR_ENCPW_CANNOT_ENCODE.get(getExceptionMessage(e));
764 err.println(wrapText(message, MAX_LINE_WIDTH));
765 return 1;
766 }
767 }
768 else
769 {
770 try
771 {
772 encodedPW = storageScheme.encodePasswordWithScheme(clearPW);
773
774 Message message =
775 ERR_ENCPW_ENCODED_PASSWORD.get(encodedPW.stringValue());
776 out.println(message);
777 }
778 catch (DirectoryException de)
779 {
780 Message message = ERR_ENCPW_CANNOT_ENCODE.get(de.getMessageObject());
781 err.println(wrapText(message, MAX_LINE_WIDTH));
782 return 1;
783 }
784 catch (Exception e)
785 {
786 Message message = ERR_ENCPW_CANNOT_ENCODE.get(getExceptionMessage(e));
787 err.println(wrapText(message, MAX_LINE_WIDTH));
788 return 1;
789 }
790 }
791 }
792
793 // If we've gotten here, then all processing completed successfully.
794 return 0;
795 }
796 }
797