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 2008 Sun Microsystems, Inc.
026     */
027    package org.opends.server.admin.std.meta;
028    
029    
030    
031    import java.util.Collection;
032    import java.util.SortedSet;
033    import org.opends.server.admin.AdministratorAction;
034    import org.opends.server.admin.AliasDefaultBehaviorProvider;
035    import org.opends.server.admin.BooleanPropertyDefinition;
036    import org.opends.server.admin.client.AuthorizationException;
037    import org.opends.server.admin.client.CommunicationException;
038    import org.opends.server.admin.client.ConcurrentModificationException;
039    import org.opends.server.admin.client.ManagedObject;
040    import org.opends.server.admin.client.MissingMandatoryPropertiesException;
041    import org.opends.server.admin.client.OperationRejectedException;
042    import org.opends.server.admin.DefaultBehaviorProvider;
043    import org.opends.server.admin.DefinedDefaultBehaviorProvider;
044    import org.opends.server.admin.IntegerPropertyDefinition;
045    import org.opends.server.admin.ManagedObjectAlreadyExistsException;
046    import org.opends.server.admin.ManagedObjectDefinition;
047    import org.opends.server.admin.PropertyOption;
048    import org.opends.server.admin.PropertyProvider;
049    import org.opends.server.admin.server.ConfigurationChangeListener;
050    import org.opends.server.admin.server.ServerManagedObject;
051    import org.opends.server.admin.std.client.CryptoManagerCfgClient;
052    import org.opends.server.admin.std.server.CryptoManagerCfg;
053    import org.opends.server.admin.StringPropertyDefinition;
054    import org.opends.server.admin.Tag;
055    import org.opends.server.admin.TopCfgDefn;
056    import org.opends.server.types.DN;
057    
058    
059    
060    /**
061     * An interface for querying the Crypto Manager managed object
062     * definition meta information.
063     * <p>
064     * The Crypto Manager provides a common interface for performing
065     * compression, decompression, hashing, encryption and other kinds of
066     * cryptographic operations.
067     */
068    public final class CryptoManagerCfgDefn extends ManagedObjectDefinition<CryptoManagerCfgClient, CryptoManagerCfg> {
069    
070      // The singleton configuration definition instance.
071      private static final CryptoManagerCfgDefn INSTANCE = new CryptoManagerCfgDefn();
072    
073    
074    
075      // The "cipher-key-length" property definition.
076      private static final IntegerPropertyDefinition PD_CIPHER_KEY_LENGTH;
077    
078    
079    
080      // The "cipher-transformation" property definition.
081      private static final StringPropertyDefinition PD_CIPHER_TRANSFORMATION;
082    
083    
084    
085      // The "digest-algorithm" property definition.
086      private static final StringPropertyDefinition PD_DIGEST_ALGORITHM;
087    
088    
089    
090      // The "key-wrapping-transformation" property definition.
091      private static final StringPropertyDefinition PD_KEY_WRAPPING_TRANSFORMATION;
092    
093    
094    
095      // The "mac-algorithm" property definition.
096      private static final StringPropertyDefinition PD_MAC_ALGORITHM;
097    
098    
099    
100      // The "mac-key-length" property definition.
101      private static final IntegerPropertyDefinition PD_MAC_KEY_LENGTH;
102    
103    
104    
105      // The "ssl-cert-nickname" property definition.
106      private static final StringPropertyDefinition PD_SSL_CERT_NICKNAME;
107    
108    
109    
110      // The "ssl-cipher-suite" property definition.
111      private static final StringPropertyDefinition PD_SSL_CIPHER_SUITE;
112    
113    
114    
115      // The "ssl-encryption" property definition.
116      private static final BooleanPropertyDefinition PD_SSL_ENCRYPTION;
117    
118    
119    
120      // The "ssl-protocol" property definition.
121      private static final StringPropertyDefinition PD_SSL_PROTOCOL;
122    
123    
124    
125      // Build the "cipher-key-length" property definition.
126      static {
127          IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "cipher-key-length");
128          builder.setOption(PropertyOption.ADVANCED);
129          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "cipher-key-length"));
130          DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("128");
131          builder.setDefaultBehaviorProvider(provider);
132          PD_CIPHER_KEY_LENGTH = builder.getInstance();
133          INSTANCE.registerPropertyDefinition(PD_CIPHER_KEY_LENGTH);
134      }
135    
136    
137    
138      // Build the "cipher-transformation" property definition.
139      static {
140          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "cipher-transformation");
141          builder.setOption(PropertyOption.ADVANCED);
142          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "cipher-transformation"));
143          DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("AES/CBC/PKCS5Padding");
144          builder.setDefaultBehaviorProvider(provider);
145          PD_CIPHER_TRANSFORMATION = builder.getInstance();
146          INSTANCE.registerPropertyDefinition(PD_CIPHER_TRANSFORMATION);
147      }
148    
149    
150    
151      // Build the "digest-algorithm" property definition.
152      static {
153          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "digest-algorithm");
154          builder.setOption(PropertyOption.ADVANCED);
155          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "digest-algorithm"));
156          DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("SHA-1");
157          builder.setDefaultBehaviorProvider(provider);
158          PD_DIGEST_ALGORITHM = builder.getInstance();
159          INSTANCE.registerPropertyDefinition(PD_DIGEST_ALGORITHM);
160      }
161    
162    
163    
164      // Build the "key-wrapping-transformation" property definition.
165      static {
166          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "key-wrapping-transformation");
167          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "key-wrapping-transformation"));
168          DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("RSA/ECB/OAEPWITHSHA-1ANDMGF1PADDING");
169          builder.setDefaultBehaviorProvider(provider);
170          PD_KEY_WRAPPING_TRANSFORMATION = builder.getInstance();
171          INSTANCE.registerPropertyDefinition(PD_KEY_WRAPPING_TRANSFORMATION);
172      }
173    
174    
175    
176      // Build the "mac-algorithm" property definition.
177      static {
178          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "mac-algorithm");
179          builder.setOption(PropertyOption.ADVANCED);
180          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "mac-algorithm"));
181          DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("HmacSHA1");
182          builder.setDefaultBehaviorProvider(provider);
183          PD_MAC_ALGORITHM = builder.getInstance();
184          INSTANCE.registerPropertyDefinition(PD_MAC_ALGORITHM);
185      }
186    
187    
188    
189      // Build the "mac-key-length" property definition.
190      static {
191          IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "mac-key-length");
192          builder.setOption(PropertyOption.ADVANCED);
193          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "mac-key-length"));
194          DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("128");
195          builder.setDefaultBehaviorProvider(provider);
196          PD_MAC_KEY_LENGTH = builder.getInstance();
197          INSTANCE.registerPropertyDefinition(PD_MAC_KEY_LENGTH);
198      }
199    
200    
201    
202      // Build the "ssl-cert-nickname" property definition.
203      static {
204          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "ssl-cert-nickname");
205          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "ssl-cert-nickname"));
206          builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "ssl-cert-nickname"));
207          PD_SSL_CERT_NICKNAME = builder.getInstance();
208          INSTANCE.registerPropertyDefinition(PD_SSL_CERT_NICKNAME);
209      }
210    
211    
212    
213      // Build the "ssl-cipher-suite" property definition.
214      static {
215          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "ssl-cipher-suite");
216          builder.setOption(PropertyOption.MULTI_VALUED);
217          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "ssl-cipher-suite"));
218          builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "ssl-cipher-suite"));
219          PD_SSL_CIPHER_SUITE = builder.getInstance();
220          INSTANCE.registerPropertyDefinition(PD_SSL_CIPHER_SUITE);
221      }
222    
223    
224    
225      // Build the "ssl-encryption" property definition.
226      static {
227          BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "ssl-encryption");
228          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "ssl-encryption"));
229          DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
230          builder.setDefaultBehaviorProvider(provider);
231          PD_SSL_ENCRYPTION = builder.getInstance();
232          INSTANCE.registerPropertyDefinition(PD_SSL_ENCRYPTION);
233      }
234    
235    
236    
237      // Build the "ssl-protocol" property definition.
238      static {
239          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "ssl-protocol");
240          builder.setOption(PropertyOption.MULTI_VALUED);
241          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "ssl-protocol"));
242          builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "ssl-protocol"));
243          PD_SSL_PROTOCOL = builder.getInstance();
244          INSTANCE.registerPropertyDefinition(PD_SSL_PROTOCOL);
245      }
246    
247    
248    
249      // Register the tags associated with this managed object definition.
250      static {
251        INSTANCE.registerTag(Tag.valueOf("security"));
252      }
253    
254    
255    
256      /**
257       * Get the Crypto Manager configuration definition singleton.
258       *
259       * @return Returns the Crypto Manager configuration definition
260       *         singleton.
261       */
262      public static CryptoManagerCfgDefn getInstance() {
263        return INSTANCE;
264      }
265    
266    
267    
268      /**
269       * Private constructor.
270       */
271      private CryptoManagerCfgDefn() {
272        super("crypto-manager", TopCfgDefn.getInstance());
273      }
274    
275    
276    
277      /**
278       * {@inheritDoc}
279       */
280      public CryptoManagerCfgClient createClientConfiguration(
281          ManagedObject<? extends CryptoManagerCfgClient> impl) {
282        return new CryptoManagerCfgClientImpl(impl);
283      }
284    
285    
286    
287      /**
288       * {@inheritDoc}
289       */
290      public CryptoManagerCfg createServerConfiguration(
291          ServerManagedObject<? extends CryptoManagerCfg> impl) {
292        return new CryptoManagerCfgServerImpl(impl);
293      }
294    
295    
296    
297      /**
298       * {@inheritDoc}
299       */
300      public Class<CryptoManagerCfg> getServerConfigurationClass() {
301        return CryptoManagerCfg.class;
302      }
303    
304    
305    
306      /**
307       * Get the "cipher-key-length" property definition.
308       * <p>
309       * Specifies the key length in bits for the preferred cipher.
310       *
311       * @return Returns the "cipher-key-length" property definition.
312       */
313      public IntegerPropertyDefinition getCipherKeyLengthPropertyDefinition() {
314        return PD_CIPHER_KEY_LENGTH;
315      }
316    
317    
318    
319      /**
320       * Get the "cipher-transformation" property definition.
321       * <p>
322       * Specifies the cipher for the Directory Server using the syntax
323       * algorithm/mode/padding.
324       * <p>
325       * The full transformation is required: specifying only an algorithm
326       * and allowing the cipher provider to supply the default mode and
327       * padding is not supported, because there is no guarantee these
328       * default values are the same among different implementations. Some
329       * cipher algorithms, including RC4 and ARCFOUR, do not have a mode
330       * or padding, and hence must be specified using NONE for the mode
331       * field and NoPadding for the padding field. For example,
332       * RC4/NONE/NoPadding.
333       *
334       * @return Returns the "cipher-transformation" property definition.
335       */
336      public StringPropertyDefinition getCipherTransformationPropertyDefinition() {
337        return PD_CIPHER_TRANSFORMATION;
338      }
339    
340    
341    
342      /**
343       * Get the "digest-algorithm" property definition.
344       * <p>
345       * Specifies the preferred message digest algorithm for the
346       * Directory Server.
347       *
348       * @return Returns the "digest-algorithm" property definition.
349       */
350      public StringPropertyDefinition getDigestAlgorithmPropertyDefinition() {
351        return PD_DIGEST_ALGORITHM;
352      }
353    
354    
355    
356      /**
357       * Get the "key-wrapping-transformation" property definition.
358       * <p>
359       * The preferred key wrapping transformation for the Directory
360       * Server. This value must be the same for all server instances in a
361       * replication topology.
362       *
363       * @return Returns the "key-wrapping-transformation" property definition.
364       */
365      public StringPropertyDefinition getKeyWrappingTransformationPropertyDefinition() {
366        return PD_KEY_WRAPPING_TRANSFORMATION;
367      }
368    
369    
370    
371      /**
372       * Get the "mac-algorithm" property definition.
373       * <p>
374       * Specifies the preferred MAC algorithm for the Directory Server.
375       *
376       * @return Returns the "mac-algorithm" property definition.
377       */
378      public StringPropertyDefinition getMacAlgorithmPropertyDefinition() {
379        return PD_MAC_ALGORITHM;
380      }
381    
382    
383    
384      /**
385       * Get the "mac-key-length" property definition.
386       * <p>
387       * Specifies the key length in bits for the preferred MAC algorithm.
388       *
389       * @return Returns the "mac-key-length" property definition.
390       */
391      public IntegerPropertyDefinition getMacKeyLengthPropertyDefinition() {
392        return PD_MAC_KEY_LENGTH;
393      }
394    
395    
396    
397      /**
398       * Get the "ssl-cert-nickname" property definition.
399       * <p>
400       * Specifies the nickname (also called the alias) of the certificate
401       * that the Crypto Manager should use when performing SSL
402       * communication.
403       * <p>
404       * This is only applicable when the Crypto Manager is configured to
405       * use SSL.
406       *
407       * @return Returns the "ssl-cert-nickname" property definition.
408       */
409      public StringPropertyDefinition getSSLCertNicknamePropertyDefinition() {
410        return PD_SSL_CERT_NICKNAME;
411      }
412    
413    
414    
415      /**
416       * Get the "ssl-cipher-suite" property definition.
417       * <p>
418       * Specifies the names of the SSL cipher suites that are allowed for
419       * use in SSL or TLS communication.
420       *
421       * @return Returns the "ssl-cipher-suite" property definition.
422       */
423      public StringPropertyDefinition getSSLCipherSuitePropertyDefinition() {
424        return PD_SSL_CIPHER_SUITE;
425      }
426    
427    
428    
429      /**
430       * Get the "ssl-encryption" property definition.
431       * <p>
432       * Specifies whether SSL/TLS is used to provide encrypted
433       * communication between two OpenDS server components.
434       *
435       * @return Returns the "ssl-encryption" property definition.
436       */
437      public BooleanPropertyDefinition getSSLEncryptionPropertyDefinition() {
438        return PD_SSL_ENCRYPTION;
439      }
440    
441    
442    
443      /**
444       * Get the "ssl-protocol" property definition.
445       * <p>
446       * Specifies the names of the SSL protocols that are allowed for use
447       * in SSL or TLS communication.
448       *
449       * @return Returns the "ssl-protocol" property definition.
450       */
451      public StringPropertyDefinition getSSLProtocolPropertyDefinition() {
452        return PD_SSL_PROTOCOL;
453      }
454    
455    
456    
457      /**
458       * Managed object client implementation.
459       */
460      private static class CryptoManagerCfgClientImpl implements
461        CryptoManagerCfgClient {
462    
463        // Private implementation.
464        private ManagedObject<? extends CryptoManagerCfgClient> impl;
465    
466    
467    
468        // Private constructor.
469        private CryptoManagerCfgClientImpl(
470            ManagedObject<? extends CryptoManagerCfgClient> impl) {
471          this.impl = impl;
472        }
473    
474    
475    
476        /**
477         * {@inheritDoc}
478         */
479        public int getCipherKeyLength() {
480          return impl.getPropertyValue(INSTANCE.getCipherKeyLengthPropertyDefinition());
481        }
482    
483    
484    
485        /**
486         * {@inheritDoc}
487         */
488        public void setCipherKeyLength(Integer value) {
489          impl.setPropertyValue(INSTANCE.getCipherKeyLengthPropertyDefinition(), value);
490        }
491    
492    
493    
494        /**
495         * {@inheritDoc}
496         */
497        public String getCipherTransformation() {
498          return impl.getPropertyValue(INSTANCE.getCipherTransformationPropertyDefinition());
499        }
500    
501    
502    
503        /**
504         * {@inheritDoc}
505         */
506        public void setCipherTransformation(String value) {
507          impl.setPropertyValue(INSTANCE.getCipherTransformationPropertyDefinition(), value);
508        }
509    
510    
511    
512        /**
513         * {@inheritDoc}
514         */
515        public String getDigestAlgorithm() {
516          return impl.getPropertyValue(INSTANCE.getDigestAlgorithmPropertyDefinition());
517        }
518    
519    
520    
521        /**
522         * {@inheritDoc}
523         */
524        public void setDigestAlgorithm(String value) {
525          impl.setPropertyValue(INSTANCE.getDigestAlgorithmPropertyDefinition(), value);
526        }
527    
528    
529    
530        /**
531         * {@inheritDoc}
532         */
533        public String getKeyWrappingTransformation() {
534          return impl.getPropertyValue(INSTANCE.getKeyWrappingTransformationPropertyDefinition());
535        }
536    
537    
538    
539        /**
540         * {@inheritDoc}
541         */
542        public void setKeyWrappingTransformation(String value) {
543          impl.setPropertyValue(INSTANCE.getKeyWrappingTransformationPropertyDefinition(), value);
544        }
545    
546    
547    
548        /**
549         * {@inheritDoc}
550         */
551        public String getMacAlgorithm() {
552          return impl.getPropertyValue(INSTANCE.getMacAlgorithmPropertyDefinition());
553        }
554    
555    
556    
557        /**
558         * {@inheritDoc}
559         */
560        public void setMacAlgorithm(String value) {
561          impl.setPropertyValue(INSTANCE.getMacAlgorithmPropertyDefinition(), value);
562        }
563    
564    
565    
566        /**
567         * {@inheritDoc}
568         */
569        public int getMacKeyLength() {
570          return impl.getPropertyValue(INSTANCE.getMacKeyLengthPropertyDefinition());
571        }
572    
573    
574    
575        /**
576         * {@inheritDoc}
577         */
578        public void setMacKeyLength(Integer value) {
579          impl.setPropertyValue(INSTANCE.getMacKeyLengthPropertyDefinition(), value);
580        }
581    
582    
583    
584        /**
585         * {@inheritDoc}
586         */
587        public String getSSLCertNickname() {
588          return impl.getPropertyValue(INSTANCE.getSSLCertNicknamePropertyDefinition());
589        }
590    
591    
592    
593        /**
594         * {@inheritDoc}
595         */
596        public void setSSLCertNickname(String value) {
597          impl.setPropertyValue(INSTANCE.getSSLCertNicknamePropertyDefinition(), value);
598        }
599    
600    
601    
602        /**
603         * {@inheritDoc}
604         */
605        public SortedSet<String> getSSLCipherSuite() {
606          return impl.getPropertyValues(INSTANCE.getSSLCipherSuitePropertyDefinition());
607        }
608    
609    
610    
611        /**
612         * {@inheritDoc}
613         */
614        public void setSSLCipherSuite(Collection<String> values) {
615          impl.setPropertyValues(INSTANCE.getSSLCipherSuitePropertyDefinition(), values);
616        }
617    
618    
619    
620        /**
621         * {@inheritDoc}
622         */
623        public boolean isSSLEncryption() {
624          return impl.getPropertyValue(INSTANCE.getSSLEncryptionPropertyDefinition());
625        }
626    
627    
628    
629        /**
630         * {@inheritDoc}
631         */
632        public void setSSLEncryption(Boolean value) {
633          impl.setPropertyValue(INSTANCE.getSSLEncryptionPropertyDefinition(), value);
634        }
635    
636    
637    
638        /**
639         * {@inheritDoc}
640         */
641        public SortedSet<String> getSSLProtocol() {
642          return impl.getPropertyValues(INSTANCE.getSSLProtocolPropertyDefinition());
643        }
644    
645    
646    
647        /**
648         * {@inheritDoc}
649         */
650        public void setSSLProtocol(Collection<String> values) {
651          impl.setPropertyValues(INSTANCE.getSSLProtocolPropertyDefinition(), values);
652        }
653    
654    
655    
656        /**
657         * {@inheritDoc}
658         */
659        public ManagedObjectDefinition<? extends CryptoManagerCfgClient, ? extends CryptoManagerCfg> definition() {
660          return INSTANCE;
661        }
662    
663    
664    
665        /**
666         * {@inheritDoc}
667         */
668        public PropertyProvider properties() {
669          return impl;
670        }
671    
672    
673    
674        /**
675         * {@inheritDoc}
676         */
677        public void commit() throws ManagedObjectAlreadyExistsException,
678            MissingMandatoryPropertiesException, ConcurrentModificationException,
679            OperationRejectedException, AuthorizationException,
680            CommunicationException {
681          impl.commit();
682        }
683    
684      }
685    
686    
687    
688      /**
689       * Managed object server implementation.
690       */
691      private static class CryptoManagerCfgServerImpl implements
692        CryptoManagerCfg {
693    
694        // Private implementation.
695        private ServerManagedObject<? extends CryptoManagerCfg> impl;
696    
697        // The value of the "cipher-key-length" property.
698        private final int pCipherKeyLength;
699    
700        // The value of the "cipher-transformation" property.
701        private final String pCipherTransformation;
702    
703        // The value of the "digest-algorithm" property.
704        private final String pDigestAlgorithm;
705    
706        // The value of the "key-wrapping-transformation" property.
707        private final String pKeyWrappingTransformation;
708    
709        // The value of the "mac-algorithm" property.
710        private final String pMacAlgorithm;
711    
712        // The value of the "mac-key-length" property.
713        private final int pMacKeyLength;
714    
715        // The value of the "ssl-cert-nickname" property.
716        private final String pSSLCertNickname;
717    
718        // The value of the "ssl-cipher-suite" property.
719        private final SortedSet<String> pSSLCipherSuite;
720    
721        // The value of the "ssl-encryption" property.
722        private final boolean pSSLEncryption;
723    
724        // The value of the "ssl-protocol" property.
725        private final SortedSet<String> pSSLProtocol;
726    
727    
728    
729        // Private constructor.
730        private CryptoManagerCfgServerImpl(ServerManagedObject<? extends CryptoManagerCfg> impl) {
731          this.impl = impl;
732          this.pCipherKeyLength = impl.getPropertyValue(INSTANCE.getCipherKeyLengthPropertyDefinition());
733          this.pCipherTransformation = impl.getPropertyValue(INSTANCE.getCipherTransformationPropertyDefinition());
734          this.pDigestAlgorithm = impl.getPropertyValue(INSTANCE.getDigestAlgorithmPropertyDefinition());
735          this.pKeyWrappingTransformation = impl.getPropertyValue(INSTANCE.getKeyWrappingTransformationPropertyDefinition());
736          this.pMacAlgorithm = impl.getPropertyValue(INSTANCE.getMacAlgorithmPropertyDefinition());
737          this.pMacKeyLength = impl.getPropertyValue(INSTANCE.getMacKeyLengthPropertyDefinition());
738          this.pSSLCertNickname = impl.getPropertyValue(INSTANCE.getSSLCertNicknamePropertyDefinition());
739          this.pSSLCipherSuite = impl.getPropertyValues(INSTANCE.getSSLCipherSuitePropertyDefinition());
740          this.pSSLEncryption = impl.getPropertyValue(INSTANCE.getSSLEncryptionPropertyDefinition());
741          this.pSSLProtocol = impl.getPropertyValues(INSTANCE.getSSLProtocolPropertyDefinition());
742        }
743    
744    
745    
746        /**
747         * {@inheritDoc}
748         */
749        public void addChangeListener(
750            ConfigurationChangeListener<CryptoManagerCfg> listener) {
751          impl.registerChangeListener(listener);
752        }
753    
754    
755    
756        /**
757         * {@inheritDoc}
758         */
759        public void removeChangeListener(
760            ConfigurationChangeListener<CryptoManagerCfg> listener) {
761          impl.deregisterChangeListener(listener);
762        }
763    
764    
765    
766        /**
767         * {@inheritDoc}
768         */
769        public int getCipherKeyLength() {
770          return pCipherKeyLength;
771        }
772    
773    
774    
775        /**
776         * {@inheritDoc}
777         */
778        public String getCipherTransformation() {
779          return pCipherTransformation;
780        }
781    
782    
783    
784        /**
785         * {@inheritDoc}
786         */
787        public String getDigestAlgorithm() {
788          return pDigestAlgorithm;
789        }
790    
791    
792    
793        /**
794         * {@inheritDoc}
795         */
796        public String getKeyWrappingTransformation() {
797          return pKeyWrappingTransformation;
798        }
799    
800    
801    
802        /**
803         * {@inheritDoc}
804         */
805        public String getMacAlgorithm() {
806          return pMacAlgorithm;
807        }
808    
809    
810    
811        /**
812         * {@inheritDoc}
813         */
814        public int getMacKeyLength() {
815          return pMacKeyLength;
816        }
817    
818    
819    
820        /**
821         * {@inheritDoc}
822         */
823        public String getSSLCertNickname() {
824          return pSSLCertNickname;
825        }
826    
827    
828    
829        /**
830         * {@inheritDoc}
831         */
832        public SortedSet<String> getSSLCipherSuite() {
833          return pSSLCipherSuite;
834        }
835    
836    
837    
838        /**
839         * {@inheritDoc}
840         */
841        public boolean isSSLEncryption() {
842          return pSSLEncryption;
843        }
844    
845    
846    
847        /**
848         * {@inheritDoc}
849         */
850        public SortedSet<String> getSSLProtocol() {
851          return pSSLProtocol;
852        }
853    
854    
855    
856        /**
857         * {@inheritDoc}
858         */
859        public Class<? extends CryptoManagerCfg> configurationClass() {
860          return CryptoManagerCfg.class;
861        }
862    
863    
864    
865        /**
866         * {@inheritDoc}
867         */
868        public DN dn() {
869          return impl.getDN();
870        }
871    
872      }
873    }