Examples with START_ELEMENT javax.xml.stream.XMLStreamConstants.START_ELEMENT used on opensource projects

Example 1 with START_ELEMENT

use of javax.xml.stream.XMLStreamConstants.START_ELEMENT in project wildfly-elytron by wildfly-security.

the class ElytronXmlParser method parseCredentialsType.

private static ExceptionSupplier<CredentialSource, ConfigXMLParseException> parseCredentialsType(final ConfigurationXMLStreamReader reader, final Version xmlVersion, final Map<String, ExceptionSupplier<KeyStore, ConfigXMLParseException>> keyStoresMap, final Map<String, ExceptionSupplier<CredentialStore, ConfigXMLParseException>> credentialStoresMap, Supplier<Provider[]> providers) throws ConfigXMLParseException {
    ExceptionUnaryOperator<CredentialSource, ConfigXMLParseException> function = parent -> CredentialSource.NONE;
    requireNoAttributes(reader);
    while (reader.hasNext()) {
        final int tag = reader.nextTag();
        if (tag == START_ELEMENT) {
            checkElementNamespace(reader, xmlVersion);
            switch(reader.getLocalName()) {
                case "key-store-reference":
                    {
                        final ExceptionSupplier<KeyStore.Entry, ConfigXMLParseException> supplier = parseKeyStoreRefType(reader, xmlVersion, keyStoresMap, credentialStoresMap, providers);
                        function = andThenOp(function, credentialSource -> credentialSource.with(new KeyStoreCredentialSource(new FixedSecurityFactory<KeyStore.Entry>(supplier.get()))));
                        break;
                    }
                case "credential-store-reference":
                    {
                        final ExceptionSupplier<CredentialSource, ConfigXMLParseException> supplier = parseCredentialStoreRefType(reader, credentialStoresMap);
                        function = andThenOp(function, credentialSource -> credentialSource.with(supplier.get()));
                        break;
                    }
                case "clear-password":
                    {
                        ExceptionSupplier<Password, ConfigXMLParseException> password = parseClearPassword(reader, providers);
                        function = andThenOp(function, credentialSource -> credentialSource.with(IdentityCredentials.NONE.withCredential(new PasswordCredential(password.get()))));
                        break;
                    }
                case "masked-password":
                    {
                        if (!xmlVersion.isAtLeast(Version.VERSION_1_4)) {
                            throw reader.unexpectedElement();
                        }
                        final XMLLocation location = reader.getLocation();
                        ExceptionSupplier<Password, ConfigXMLParseException> password = parseMaskedPassword(reader, providers);
                        Password maskedPassword = password.get();
                        Password finalPassword;
                        try {
                            final PasswordFactory passwordFactory = PasswordFactory.getInstance(maskedPassword.getAlgorithm(), providers);
                            final ClearPasswordSpec spec = passwordFactory.getKeySpec(maskedPassword, ClearPasswordSpec.class);
                            final char[] clearPassword = spec.getEncodedPassword();
                            PasswordFactory clearPasswordFactory = PasswordFactory.getInstance(ClearPassword.ALGORITHM_CLEAR, providers);
                            finalPassword = clearPasswordFactory.generatePassword(new ClearPasswordSpec(clearPassword)).castAs(ClearPassword.class);
                        } catch (InvalidKeySpecException | NoSuchAlgorithmException cause) {
                            throw xmlLog.xmlFailedToCreateCredential(location, cause);
                        }
                        function = andThenOp(function, credentialSource -> credentialSource.with(IdentityCredentials.NONE.withCredential(new PasswordCredential(finalPassword))));
                        break;
                    }
                case "key-pair":
                    {
                        KeyPairCredential keyPairCredential = parseKeyPair(reader, xmlVersion, credentialStoresMap, providers);
                        function = andThenOp(function, credentialSource -> credentialSource.with(IdentityCredentials.NONE.withCredential(keyPairCredential)));
                        break;
                    }
                case "certificate":
                    {
                        X509CertificateChainPrivateCredential credential = parseCertificateType(reader, xmlVersion);
                        function = andThenOp(function, credentialSource -> credentialSource.with(IdentityCredentials.NONE.withCredential(credential)));
                        break;
                    }
                case "public-key-pem":
                    {
                        PublicKey publicKey = parsePem(reader, PublicKey.class);
                        function = andThenOp(function, credentialSource -> credentialSource.with(IdentityCredentials.NONE.withCredential(new PublicKeyCredential(publicKey))));
                        break;
                    }
                case "bearer-token":
                    {
                        BearerTokenCredential bearerToken = parseBearerTokenType(reader);
                        function = andThenOp(function, credentialSource -> credentialSource.with(IdentityCredentials.NONE.withCredential(bearerToken)));
                        break;
                    }
                case "oauth2-bearer-token":
                    {
                        final ExceptionSupplier<CredentialSource, ConfigXMLParseException> oauthCredentialSourceSupplier = parseOAuth2BearerTokenType(reader, credentialStoresMap, xmlVersion);
                        function = andThenOp(function, credentialSource -> credentialSource.with(oauthCredentialSourceSupplier.get()));
                        break;
                    }
                case "local-kerberos":
                    {
                        if (!xmlVersion.isAtLeast(Version.VERSION_1_1)) {
                            throw reader.unexpectedElement();
                        }
                        CredentialSource kerberosCredentialSource = parseLocalKerberos(reader);
                        function = andThenOp(function, credentialSource -> credentialSource.with(kerberosCredentialSource));
                        xmlLog.xmlDeprecatedElement(reader.getLocalName(), reader.getLocation());
                        break;
                    }
                case "ssh-credential":
                    {
                        if (!xmlVersion.isAtLeast(Version.VERSION_1_6)) {
                            throw reader.unexpectedElement();
                        }
                        SSHCredential sshCredential = parseSSHKeyLocationCredential(reader, xmlVersion, credentialStoresMap, providers);
                        function = andThenOp(function, credentialSource -> credentialSource.with(credentialSource.with(IdentityCredentials.NONE.withCredential(sshCredential))));
                        break;
                    }
                default:
                    {
                        throw reader.unexpectedElement();
                    }
            }
        } else if (tag == END_ELEMENT) {
            assert reader.getLocalName().equals("credentials") || reader.getLocalName().equals("protection-parameter-credentials");
            final ExceptionUnaryOperator<CredentialSource, ConfigXMLParseException> finalFunction = function;
            return () -> finalFunction.apply(null);
        } else {
            throw reader.unexpectedContent();
        }
    }
    throw reader.unexpectedDocumentEnd();
}

Example 2 with START_ELEMENT

use of javax.xml.stream.XMLStreamConstants.START_ELEMENT in project jpx by jenetics.

the class ListResult method read.

@Override
public List<T> read(final XMLStreamReader xml, final boolean lenient) throws XMLStreamException {
    xml.require(START_ELEMENT, null, name());
    final T element = _adoptee.read(xml, lenient);
    return element != null ? Collections.singletonList(element) : emptyList();
}

Example 3 with START_ELEMENT

use of javax.xml.stream.XMLStreamConstants.START_ELEMENT in project wildfly-elytron by wildfly-security.

the class ElytronXmlParser method parseKeyStoreType.

/**
 * Parse an XML element of type {@code key-store-type} from an XML reader.
 *
 * @param reader the XML stream reader
 * @param xmlVersion the version of parsed XML
 * @param keyStoresMap the map of key stores to use
 * @throws ConfigXMLParseException if the resource failed to be parsed
 */
static void parseKeyStoreType(ConfigurationXMLStreamReader reader, final Version xmlVersion, final Map<String, ExceptionSupplier<KeyStore, ConfigXMLParseException>> keyStoresMap, final Map<String, ExceptionSupplier<CredentialStore, ConfigXMLParseException>> credentialStoresMap, final Supplier<Provider[]> providers) throws ConfigXMLParseException {
    final int attributeCount = reader.getAttributeCount();
    String name = null;
    String type = null;
    String provider = null;
    Boolean wrap = null;
    DeferredSupplier<Provider[]> providersSupplier = new DeferredSupplier<>(providers);
    for (int i = 0; i < attributeCount; i++) {
        checkAttributeNamespace(reader, i);
        switch(reader.getAttributeLocalName(i)) {
            case "type":
                {
                    if (type != null)
                        throw reader.unexpectedAttribute(i);
                    type = reader.getAttributeValueResolved(i);
                    break;
                }
            case "provider":
                {
                    if (provider != null)
                        throw reader.unexpectedAttribute(i);
                    provider = reader.getAttributeValueResolved(i);
                    break;
                }
            case "name":
                {
                    if (name != null)
                        throw reader.unexpectedAttribute(i);
                    name = reader.getAttributeValueResolved(i);
                    break;
                }
            case "wrap-passwords":
                {
                    if (wrap != null)
                        throw reader.unexpectedAttribute(i);
                    wrap = Boolean.valueOf(Boolean.parseBoolean(reader.getAttributeValueResolved(i)));
                    break;
                }
            default:
                throw reader.unexpectedAttribute(i);
        }
    }
    if (type == null && !xmlVersion.isAtLeast(Version.VERSION_1_3)) {
        throw missingAttribute(reader, "type");
    }
    if (name == null) {
        throw missingAttribute(reader, "name");
    }
    final XMLLocation location = reader.getLocation();
    ExceptionSupplier<char[], ConfigXMLParseException> passwordFactory = null;
    boolean gotSource = false;
    boolean gotCredential = false;
    boolean gotProviders = false;
    String fileSource = null;
    ExceptionSupplier<InputStream, IOException> resourceSource = null;
    URI uriSource = null;
    while (reader.hasNext()) {
        final int tag = reader.nextTag();
        if (tag == START_ELEMENT) {
            checkElementNamespace(reader, xmlVersion);
            switch(reader.getLocalName()) {
                case "key-store-credential":
                    {
                        // group 2
                        if (gotCredential) {
                            throw reader.unexpectedElement();
                        }
                        gotCredential = true;
                        final XMLLocation nestedLocation = reader.getLocation();
                        final ExceptionSupplier<KeyStore.Entry, ConfigXMLParseException> entryFactory = parseKeyStoreRefType(reader, xmlVersion, keyStoresMap, credentialStoresMap, providersSupplier);
                        passwordFactory = () -> {
                            final KeyStore.Entry entry = entryFactory.get();
                            if (entry instanceof PasswordEntry)
                                try {
                                    final Password password = ((PasswordEntry) entry).getPassword();
                                    final PasswordFactory passwordFactory1 = PasswordFactory.getInstance(password.getAlgorithm(), providersSupplier);
                                    final ClearPasswordSpec passwordSpec = passwordFactory1.getKeySpec(password, ClearPasswordSpec.class);
                                    return passwordSpec.getEncodedPassword();
                                } catch (GeneralSecurityException e) {
                                    throw xmlLog.xmlFailedToCreateCredential(nestedLocation, e);
                                }
                            return null;
                        };
                        break;
                    }
                case "credential-store-reference":
                    {
                        if (gotCredential || !xmlVersion.isAtLeast(Version.VERSION_1_0_1)) {
                            throw reader.unexpectedElement();
                        }
                        gotCredential = true;
                        final XMLLocation nestedLocation = reader.getLocation();
                        ExceptionSupplier<CredentialSource, ConfigXMLParseException> credentialSourceSupplier = parseCredentialStoreRefType(reader, credentialStoresMap);
                        passwordFactory = () -> {
                            try {
                                return credentialSourceSupplier.get().applyToCredential(PasswordCredential.class, c -> c.getPassword().castAndApply(ClearPassword.class, ClearPassword::getPassword));
                            } catch (IOException e) {
                                throw xmlLog.xmlFailedToCreateCredential(nestedLocation, e);
                            }
                        };
                        break;
                    }
                case "key-store-clear-password":
                    {
                        // group 2
                        if (gotCredential) {
                            throw reader.unexpectedElement();
                        }
                        gotCredential = true;
                        final ExceptionSupplier<Password, ConfigXMLParseException> clearPassword = parseClearPassword(reader, providersSupplier);
                        passwordFactory = () -> ((ClearPassword) clearPassword.get()).getPassword();
                        break;
                    }
                case "key-store-masked-password":
                    {
                        // group 2
                        if (gotCredential || !xmlVersion.isAtLeast(Version.VERSION_1_4)) {
                            throw reader.unexpectedElement();
                        }
                        gotCredential = true;
                        final XMLLocation nestedLocation = reader.getLocation();
                        final ExceptionSupplier<Password, ConfigXMLParseException> maskedPassword = parseMaskedPassword(reader, providersSupplier);
                        passwordFactory = () -> {
                            try {
                                Password password = maskedPassword.get();
                                PasswordFactory factory = PasswordFactory.getInstance(password.getAlgorithm(), providersSupplier);
                                ClearPasswordSpec spec = factory.getKeySpec(password, ClearPasswordSpec.class);
                                return spec.getEncodedPassword();
                            } catch (GeneralSecurityException e) {
                                throw xmlLog.xmlFailedToCreateCredential(nestedLocation, e);
                            }
                        };
                        break;
                    }
                case "file":
                    {
                        // group 1
                        if (gotSource || gotCredential) {
                            throw reader.unexpectedElement();
                        }
                        gotSource = true;
                        fileSource = parseNameType(reader);
                        break;
                    }
                case "resource":
                    {
                        // group 1
                        if (gotSource || gotCredential) {
                            throw reader.unexpectedElement();
                        }
                        gotSource = true;
                        resourceSource = parseResourceType(reader, xmlVersion);
                        break;
                    }
                case "uri":
                    {
                        // group 1
                        if (gotSource || gotCredential) {
                            throw reader.unexpectedElement();
                        }
                        gotSource = true;
                        uriSource = parseUriType(reader);
                        break;
                    }
                case "providers":
                    {
                        if (gotProviders || !xmlVersion.isAtLeast(Version.VERSION_1_1)) {
                            throw reader.unexpectedElement();
                        }
                        gotProviders = true;
                        Supplier<Provider[]> supplier = parseProvidersType(reader, xmlVersion);
                        if (supplier != null) {
                            providersSupplier.setSupplier(supplier);
                        }
                        break;
                    }
                default:
                    throw reader.unexpectedElement();
            }
        } else if (tag == END_ELEMENT) {
            ExceptionSupplier<KeyStore, ConfigXMLParseException> keyStoreFactory = null;
            if (type == null || type.equalsIgnoreCase("automatic")) {
                keyStoreFactory = new UnknownTypeFileKeyStoreFactory(providers, provider, passwordFactory, fileSource, resourceSource, uriSource, location);
                if (wrap) {
                    keyStoreFactory = new PasswordKeyStoreFactory(keyStoreFactory);
                }
            } else {
                keyStoreFactory = new KeyStoreCreateFactory(providersSupplier, provider, type, location);
                if (wrap == Boolean.TRUE) {
                    keyStoreFactory = new PasswordKeyStoreFactory(keyStoreFactory);
                }
                if (fileSource != null) {
                    keyStoreFactory = new FileLoadingKeyStoreFactory(keyStoreFactory, passwordFactory, fileSource, location);
                } else if (resourceSource != null) {
                    keyStoreFactory = new ResourceLoadingKeyStoreFactory(keyStoreFactory, passwordFactory, resourceSource, location);
                } else if (uriSource != null) {
                    keyStoreFactory = new URILoadingKeyStoreFactory(keyStoreFactory, passwordFactory, uriSource, location);
                } else {
                    keyStoreFactory = new NullLoadingKeyStoreFactory(keyStoreFactory, passwordFactory, location);
                }
            }
            keyStoresMap.put(name, keyStoreFactory);
            return;
        } else {
            throw reader.unexpectedContent();
        }
    }
    throw reader.unexpectedDocumentEnd();
}

Example 4 with START_ELEMENT

use of javax.xml.stream.XMLStreamConstants.START_ELEMENT in project wildfly-elytron by wildfly-security.

the class ElytronXmlParser method parseOpenSSHKeyType.

private static KeyPair parseOpenSSHKeyType(final ConfigurationXMLStreamReader reader, final Version xmlVersion, final Map<String, ExceptionSupplier<CredentialStore, ConfigXMLParseException>> credentialStoresMap, Supplier<Provider[]> providers) throws ConfigXMLParseException {
    final int attributeCount = reader.getAttributeCount();
    ExceptionUnaryOperator<CredentialSource, ConfigXMLParseException> function = parent -> CredentialSource.NONE;
    String keyContent = null;
    for (int i = 0; i < attributeCount; i++) {
        checkAttributeNamespace(reader, i);
        switch(reader.getAttributeLocalName(i)) {
            case "pem":
                {
                    if (keyContent != null)
                        throw reader.unexpectedAttribute(i);
                    keyContent = reader.getAttributeValueResolved(i);
                    break;
                }
            default:
                throw reader.unexpectedAttribute(i);
        }
    }
    while (reader.hasNext()) {
        final int tag = reader.nextTag();
        if (tag == START_ELEMENT) {
            checkElementNamespace(reader, xmlVersion);
            switch(reader.getLocalName()) {
                case "credential-store-reference":
                    {
                        final ExceptionSupplier<CredentialSource, ConfigXMLParseException> supplier = parseCredentialStoreRefType(reader, credentialStoresMap);
                        function = andThenOp(function, credentialSource -> credentialSource.with(supplier.get()));
                        break;
                    }
                case "clear-password":
                    {
                        ExceptionSupplier<Password, ConfigXMLParseException> password = parseClearPassword(reader, providers);
                        function = andThenOp(function, credentialSource -> credentialSource.with(IdentityCredentials.NONE.withCredential(new PasswordCredential(password.get()))));
                        break;
                    }
                case "masked-password":
                    {
                        if (!xmlVersion.isAtLeast(Version.VERSION_1_4)) {
                            throw reader.unexpectedElement();
                        }
                        final XMLLocation location = reader.getLocation();
                        ExceptionSupplier<Password, ConfigXMLParseException> password = parseMaskedPassword(reader, providers);
                        Password maskedPassword = password.get();
                        Password finalPassword;
                        try {
                            final PasswordFactory passwordFactory = PasswordFactory.getInstance(maskedPassword.getAlgorithm(), providers);
                            final ClearPasswordSpec spec = passwordFactory.getKeySpec(maskedPassword, ClearPasswordSpec.class);
                            final char[] clearPassword = spec.getEncodedPassword();
                            PasswordFactory clearPasswordFactory = PasswordFactory.getInstance(ClearPassword.ALGORITHM_CLEAR, providers);
                            finalPassword = clearPasswordFactory.generatePassword(new ClearPasswordSpec(clearPassword)).castAs(ClearPassword.class);
                        } catch (InvalidKeySpecException | NoSuchAlgorithmException cause) {
                            throw xmlLog.xmlFailedToCreateCredential(location, cause);
                        }
                        function = andThenOp(function, credentialSource -> credentialSource.with(IdentityCredentials.NONE.withCredential(new PasswordCredential(finalPassword))));
                        break;
                    }
                default:
                    throw reader.unexpectedElement();
            }
        } else if (tag == END_ELEMENT) {
            if (keyContent == null)
                throw reader.missingRequiredAttribute(reader.getNamespaceURI(), "openssh-private-key");
            final ExceptionUnaryOperator<CredentialSource, ConfigXMLParseException> finalFunction = function;
            ElytronFilePasswordProvider passwordProvider = new ElytronFilePasswordProvider(() -> finalFunction.apply(null));
            Iterator<PemEntry<?>> pemContent = Pem.parsePemOpenSSHContent(CodePointIterator.ofString(keyContent), passwordProvider);
            final PemEntry<?> pemEntry = pemContent.next();
            final KeyPair keyPair = pemEntry.tryCast(KeyPair.class);
            if (keyPair == null)
                throw xmlLog.xmlInvalidOpenSSHKey(reader);
            return keyPair;
        } else {
            throw reader.unexpectedContent();
        }
    }
    throw reader.unexpectedDocumentEnd();
}