docs: @SuppressWarnings("deprecation")
      public synchronized final void prepareLTPAKeyInfo(WsLocationAdmin locService, String keyImportFile, @Sensitive byte[] keyPassword) throws Exception {
          if (!this.importFileCache.contains(keyImportFile)) {
              // Need to load the key import file
              if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                  Tr.event(this, tc, "Loading keyfile [" + keyImportFile + "]");
              }
              Properties props = null;
  
              //Check to see if the LTPA key import file exists create the keys and file if not
              WsResource ltpaKeyFileResource = getLTPAKeyFileResource(locService, keyImportFile);
              if (ltpaKeyFileResource != null) {
                  props = loadPropertiesFile(ltpaKeyFileResource);
              } else {
                  long start = System.currentTimeMillis();
                  Tr.info(tc, "LTPA_CREATE_KEYS_START");
  
                  LTPAKeyFileCreator creator = new LTPAKeyFileCreatorImpl();
                  props = creator.createLTPAKeysFile(locService, keyImportFile, keyPassword);
  
                  Tr.audit(tc, "LTPA_CREATE_KEYS_COMPLETE", TimestampUtils.getElapsedTime(start), keyImportFile);
              }
  
              String realm = props.getProperty(LTPAKeyFileUtility.KEYIMPORT_REALM);
              String secretKeyStr = props.getProperty(LTPAKeyFileUtility.KEYIMPORT_SECRETKEY);
              String privateKeyStr = props.getProperty(LTPAKeyFileUtility.KEYIMPORT_PRIVATEKEY);
              String publicKeyStr = props.getProperty(LTPAKeyFileUtility.KEYIMPORT_PUBLICKEY);
  
              byte[] secretKey, privateKey, publicKey;
              try {
                  KeyEncryptor encryptor = new KeyEncryptor(keyPassword);
                  // Secret key
                  if ((secretKeyStr == null) || (secretKeyStr.length() == 0)) {
                      Tr.error(tc, "LTPA_TOKEN_SERVICE_MISSING_KEY", LTPAKeyFileUtility.KEYIMPORT_SECRETKEY);
                      String formattedMessage = Tr.formatMessage(tc, "LTPA_TOKEN_SERVICE_MISSING_KEY", LTPAKeyFileUtility.KEYIMPORT_SECRETKEY);
                      throw new IllegalArgumentException(formattedMessage);
                  } else {
                      byte[] keyEncoded = Base64Coder.base64DecodeString(secretKeyStr);
                      secretKey = encryptor.decrypt(keyEncoded);
                  }
                  // Private key
                  if ((privateKeyStr == null) || (privateKeyStr.length() == 0)) {
                      Tr.error(tc, "LTPA_TOKEN_SERVICE_MISSING_KEY", LTPAKeyFileUtility.KEYIMPORT_PRIVATEKEY);
                      String formattedMessage = Tr.formatMessage(tc, "LTPA_TOKEN_SERVICE_MISSING_KEY", LTPAKeyFileUtility.KEYIMPORT_PRIVATEKEY);
                      throw new IllegalArgumentException(formattedMessage);
                  } else {
                      byte[] keyEncoded = Base64Coder.base64DecodeString(privateKeyStr);
                      privateKey = encryptor.decrypt(keyEncoded);
                  }
                  // Public key
                  if ((publicKeyStr == null) || (publicKeyStr.length() == 0)) {
                      Tr.error(tc, "LTPA_TOKEN_SERVICE_MISSING_KEY", LTPAKeyFileUtility.KEYIMPORT_PUBLICKEY);
                      String formattedMessage = Tr.formatMessage(tc, "LTPA_TOKEN_SERVICE_MISSING_KEY", LTPAKeyFileUtility.KEYIMPORT_PUBLICKEY);
                      throw new IllegalArgumentException(formattedMessage);
                  } else {
                      byte[] keyEncoded = Base64Coder.base64DecodeString(publicKeyStr);
                      publicKey = keyEncoded;
                  }
              } catch (Exception e) {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                      Tr.event(this, tc, "Error loading key; " + e);
                  }
                  throw e;
              }
  
              if (secretKey != null) {
                  this.keyCache.put(keyImportFile + SECRETKEY, secretKey);
              }
              if (privateKey != null) {
                  this.keyCache.put(keyImportFile + PRIVATEKEY, privateKey);
              }
              if (publicKey != null) {
                  this.keyCache.put(keyImportFile + PUBLICKEY, publicKey);
              }
              if (realm != null) {
                  this.realmCache.put(keyImportFile, realm);
              }
              this.importFileCache.add(keyImportFile);
          }
      }