Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package me.yanaga.opes;
  
  /*
   * #%L
   * opes
   * %%
   * Copyright (C) 2015 Edson Yanaga
   * %%
   * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  * 
  *      http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * #L%
  */
 
 
 import java.util.List;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 public final class CertificadoDigital implements Serializable {
 
 	private static final long serialVersionUID = 1L;
 
 	private static final String C14N_TRANSFORM_METHOD = "http://www.w3.org/TR/2001/REC-xml-c14n-20010315";
 
 	private static final char[] DEFAULT_CERTIFICATE_PASSWORD = { 'o''p''e''s' };
 
 	private static final ASN1ObjectIdentifier OID_CNPJ = new ASN1ObjectIdentifier("2.16.76.1.3.3");
 
 	private final transient byte[] bytes;
 
 	private final transient CpfCnpj cnpj;
 
 	private final transient PrivateKey privateKey;
 
 	private final transient X509Certificate[] certificateChain;
 
 	private CertificadoDigital(byte[] bytesCpfCnpj cpfCnpjPrivateKey privateKeyX509Certificate[] certificateChain) {
 		this. = bytes;
 		this. = cpfCnpj;
 		this. = privateKey;
		this. = certificateChain;
	}
	public static CertificadoDigital of(InputStream in) {
	}
	public static CertificadoDigital of(InputStream inchar[] password) {
		try {
			KeyStore keyStore = KeyStore.getInstance("pkcs12");
			keyStore.load(inpassword);
			for (Enumeration<Stringaliases = keyStore.aliases(); aliases.hasMoreElements(); ) {
				String alias = aliases.nextElement();
				if (!keyStore.isKeyEntry(alias)) {
					continue;
				}
				Key key = keyStore.getKey(aliaspassword);
				if (!(key instanceof PrivateKey)) {
					continue;
				}
				Certificate[] certs = keyStore.getCertificateChain(alias);
				if ((certs == null) || (certs.length == 0) || !(certs[0] instanceof X509Certificate)) {
					continue;
				}
				if (!(certs instanceof X509Certificate[])) {
					Certificate[] tmp = new X509Certificate[certs.length];
					System.arraycopy(certs, 0, tmp, 0, certs.length);
					certs = tmp;
				}
				return new CertificadoDigital(baos.toByteArray(), extractCnpj(certs), (PrivateKeykey, (X509Certificate[]) certs);
			}
			throw new IllegalArgumentException("Unable to load PrivateKey and CertificateChain from KeyStore.");
		}
		catch (Exception e) {
		}
	}
	public byte[] toBytes() {
		return ;
	}
	public Optional<CpfCnpjgetCnpj() {
		return Optional.ofNullable();
	}
	public <T extends Node> T sign(T node) {
		checkArgument(node instanceof Document || node instanceof Element);
		try {
			Element element = node instanceof Document ? ((Documentnode).getDocumentElement() : (Elementnode;
			DOMSignContext dsc = new DOMSignContext(element);
			XMLSignatureFactory signatureFactory = XMLSignatureFactory.getInstance("DOM");
			List<TransformtransformList = new LinkedList<>();
			transformList.add(signatureFactory.newTransform(., (TransformParameterSpecnull));
			transformList.add(signatureFactory.newTransform(, (TransformParameterSpecnull));
			Node child = findFirstElementChild(element);
			((Elementchild).setIdAttribute("Id"true);
			String uri = String.format("#%s"id);
			Reference reference = signatureFactory.newReference(uri,
					signatureFactory.newDigestMethod(.null), transformListnullnull);
			SignedInfo signedInfo = signatureFactory.newSignedInfo(signatureFactory.newCanonicalizationMethod(
					.newSignatureMethod(.null), Collections.singletonList(reference));
			KeyInfoFactory kif = signatureFactory.getKeyInfoFactory();
			X509Data x509Data = kif.newX509Data(Collections.singletonList([0]));
			KeyInfo keyInfo = kif.newKeyInfo(Collections.singletonList(x509Data));
			XMLSignature xmlSignature = signatureFactory.newXMLSignature(signedInfokeyInfo);
			xmlSignature.sign(dsc);
			return node;
		}
		catch (Exception ex) {
			throw new IllegalArgumentException("Erro ao assinar XML."ex);
		}
	}
	public boolean validate(Document document) {
		checkNotNull(document);
		try {
			NodeList nl = document.getElementsByTagNameNS(."Signature");
			DOMValidateContext valContext = new DOMValidateContext(new X509KeySelector(), nl.item(0));
			XMLSignatureFactory signatureFactory = XMLSignatureFactory.getInstance("DOM");
			XMLSignature signature = signatureFactory.unmarshalXMLSignature(valContext);
			return signature.validate(valContext);
		}
		catch (Exception ex) {
			throw new IllegalArgumentException("Erro ao validar o XML."ex);
		}
	}
	private Node findFirstElementChild(Node node) {
		NodeList childNodes = node.getChildNodes();
		Node child = null;
		for (int i = 0; i < childNodes.getLength(); i++) {
			Node childNode = childNodes.item(i);
			if (childNode.getNodeType() == .) {
				child = childNode;
				break;
			}
		}
		return child;
	}
	private static CpfCnpj extractCnpj(Certificate[] certs) {
		X509Certificate[] certificates = (X509Certificate[]) certs;
		for (X509Certificate certificate : certificates) {
			try {
				for (Object obj : X509ExtensionUtil.getSubjectAlternativeNames(certificate)) {
					if (obj instanceof List) {
						List values = (Listobj;
						if (values.get(1) instanceof DLSequence) {
							DLSequence seq = (DLSequencevalues.get(1);
							if (.equals(oid)) {
								ASN1Object derObj = tagged.getObject();
								try {
									String s = new String(derObj.getEncoded());
									return CpfCnpj.of(s);
								}
								catch (IOException e) {
								}
							}
						}
					}
				}
			}
				throw new IllegalArgumentException("Erro ao extrair CNPJ do CertificadoDigital"e);
			}
		}
		return null;
	}
		throw new InvalidObjectException("Proxy required");
	}
	private Object writeReplace() {
		return new SerializationProxy(this);
	}
	private static class SerializationProxy implements Serializable {
		private static final long serialVersionUID = 1L;
		private final byte[] bytes;
		SerializationProxy(CertificadoDigital certificadoDigital) {
			this. = certificadoDigital.bytes;
		}
		private Object readResolve() {
			return CertificadoDigital.of(new ByteArrayInputStream());
		}
	}
	private static class X509KeySelector extends KeySelector {
		public KeySelectorResult select(KeyInfo keyInfoPurpose purposeAlgorithmMethod method,
			@SuppressWarnings("unchecked")
			while (ki.hasNext()) {
				XMLStructure info = ki.next();
				if (info instanceof X509Data) {
					X509Data x509Data = (X509Datainfo;
					@SuppressWarnings("unchecked")
					Iterator<Objectxi = x509Data.getContent().iterator();
					while (xi.hasNext()) {
						Object o = xi.next();
						if (!(o instanceof X509Certificate))
							continue;
						final PublicKey key = ((X509Certificateo).getPublicKey();
						if (algEquals(method.getAlgorithm(), key.getAlgorithm())) {
							return new KeySelectorResult() {
								public Key getKey() {
									return key;
								}
							};
						}
					}
				}
			}
			throw new KeySelectorException("No KeyValue element found!");
		}
		static boolean algEquals(String algURIString algName) {
			if (algName.equalsIgnoreCase("DSA") && algURI.equalsIgnoreCase(.)) {
				return true;
			}
			else if (algName.equalsIgnoreCase("RSA") && algURI.equalsIgnoreCase(.)) {
				return true;
			}
			else {
				return false;
			}
		}
	}
New to GrepCode? Check out our FAQ X