2010
Facturación Digital Comprobante Fiscal Digital por Internet Descripción del proceso paso a paso para poder generar tus propios Comprobantes Fiscales (CFDI), con ejemplos explicados y comentados usando JAVA
Departamento de Informacion y de Sistemas Universidad de Montemorelos 19/10/2010
Contenido FACTURACION DIGITAL .................................................................................................................. 2 Introduccion .................................................................................................................................. 2 Algunas definiciones ...................................................................................................................... 2 Contenido del Anexo 20 Anexo 20 20 de la Primera Resolución de Modificaciones Modificaciones a la Resolución Miscelánea Fiscal para 2010, publicada el 14 de septiembre de 2010. ........................................ ......................... ............... 3 Pasos para la creación de un CFDI .................................................................................................. 4 PASO 1: Crear estructura de clases y documentación básica ................................................ ....................... ................................ ....... 4 Algunas notas aclaratorias y recomendaciones: .................................................. ......................... ............................................. .................... 7 Fuente y sitios recomendados: ............................................................................................... 8 PASO 2: Generar Cadena Original del CFDI SIN TimbreFiscalDigital ............................................. 8 Reglas Generales para la generación de la Cadena Original .................................................... 8 Secuencia de Formación de la Cadena Original ....................................................................... 9 Algunas notas aclaratorias y recomendaciones:.................................................. ......................... ........................................... .................. 13 Fuente y sitios recomendados: ............................................................................................. 13 PASO 3: Generar Sello Digital ................................................................................................... 13 Procedimiento...................................................................................................................... 14 Algunas notas aclaratorias y recomendaciones:.................................................. ......................... ........................................... .................. 16 Fuente y sitios recomendados: ............................................................................................. 16 PASO 4: Generar y validar XML del Comprobante ................................................... .......................... ........................................... .................. 17
Algunas notas aclaratorias y recomendaciones:..................................................................... 23 Fuente y sitios recomendados: ............................................................................................. 24 PASO 5: Generar Cadena Original del Timbre Fiscal Digital ....................................................... 24 Ejemplo de cadena original de un timbre: ............................................................................ 24 Fuente y sitios recomendados: ............................................................................................. 25 PASO 6: Generar Generar y validar XML del Timbre Fiscal Digital ................................................. ........................ .................................. ......... 25 Fuente y sitios recomendados: ............................................................................................. 25 PASO 7: Juntar (concatenar) el XML obtenido obtenido del Comprobante + XML del TimbreFiscalDigital TimbreFiscalDigital 25 Fuente y sitios recomendados: ............................................................................................. 26 OTROS ..................................................................................................................................... 26
FACTURACION DIGITAL
Introduccion Después de mucho leer, investigar en foros, entender el Anexo 20 del SAT y demás, esto es lo que hemos logrado entender y que nos queda claro.
Aclaro que todo lo que se muestre a continuación está basado en la versión 3 de los Comprobantes Digitales, que entrara en vigor a partir del 1/Enero/2011 y construido sobre el lenguaje de programación JAVA. Algunas definiciones CFDI: Comprobante Fiscal Digital por Internet Anexo 20: Tu Biblia para la Facturacion Digital. Es un pdf hecho por el SAT donde esta
detallado y especificado los estándares y formatos que deben cumplir los CFD o CFDI Cadena Original: El elemento a sellar. secuencia de datos formada con la información
contenida dentro del comprobante fiscal digital por internet, establecida en el Rubro II.A “Estándar de comprobante fiscal digital por internet” de este anexo (Anexo 20). Sello Digital: Resultado de la secuencia de algoritmos aplicados a la Cadena Original para
hacer que el Comprobante Fiscal tenga las características de: Infalsificable y Único. XSD: Es un lenguaje de esquema utilizado para describir la estructura y las restricciones de
los contenidos de los documentos XML de una forma muy precisa, más allá de las normas sintácticas impuestas por el propio lenguaje XML. En palabras que nosotros hemos entendido, el XSD no es básicamente una plantilla donde se especifica la estructura, tipos de datos y requisitos que debe cumplir un documento XML. Y se usa precisamente para verificar si un documento XML cumple o no con los elementos de la plantilla.
Contenido del Anexo 20 Anexo 20 de la Primera Resolución de Modificaciones a la Resolución Miscelánea Fiscal para 2010, publicada el 14 de septiembre de 2010.
Cuyo contenido trata de los Medios electrónicos I. Del Comprobante Fiscal Digital: A. Características técnicas del archivo que contenga el informe mensual de comprobantes fiscales digitales emitidos B. Estándar de comprobante fiscal digital C. Generación de sellos digitales para comprobantes fiscales digitales II. Del Comprobante Fiscal Digital por Internet: A. Estándar de comprobante fiscal digital por internet B. Generación de sellos digitales para comprobantes fiscales digitales por internet C. Estándar y uso del complemento obligatorio: Timbre Fiscal Digital del SAT D. Estándar del servicio de cancelación E. Especificación técnica del código de barras bidimensional III. De los distintos medios de comprobación digital: A. Estándares y especificaciones técnicas que deberán cumplir las aplicaciones informáticas para la generación de claves de criptografía asimétrica a utilizar para Firma Electrónica Avanzada B. Uso de la facilidad de nodos opcionales y C. Uso de la facilidad de ensobretado
Pasos para la creación de un CFDI PASO 1: Crear estructura de clases y documentación básica
Estas son las clases que deben crearse con sus atributos y tipo. Se muestran en orden jerárquico. Fueron extraidas directamente del Anexo 20. Solo se detallan algunos atributos que se consideran son un poco complicado de entender o que se prestan a confusión; mas características deberán consultarse directamente en el Anexo 20 del SAT. TIPOS SIMPLES Comprobante String versión //3.0 String serie //Serie para control interno del Contribuyente (1-25 caracteres) String folio //Folio para control interno del Contribuyente Date fecha String sello //Sello Digital del Comprobante (en Base 64) String formaDePago String noCertificado //Número de serie del certificado de sello digital (lo otorga el SAT) String certificado //Certificado del sello digital (en Base 64) String condicionesDePago T_Importe subtotal //Suma de los importes de los Conceptos antes de descuentos e impuestos T_Importe descuento String motivoDescuento String tipoCambio //Tipo de Cambio según la moneda usada String moneda //Moneda utilizada para expresar los montos T_Importe total //Suma del total – descuentos aplicables + descuentos trasladados – impuestos retenidos String metodoDePago String tipoDeComprobante Emisor emisor Receptor receptor Conceptos Impuestos Complemento //Nodo opcional donde se incluirá el complemento Timbre Fiscal Digital de manera obligatoria y los nodos complementarios determinados por el SAT, de acuerdo a las disposiciones particulares a un sector o actividad específica. Addenda // Nodo opcional para recibir las extensiones al presente formato que sean de utilidad al contribuyente. Para las reglas de uso del mismo, referirse al formato de origen
Emisor
T_Rfc rfc String nombre DomicilioFiscal domicilioFiscal ExpedidoEn expedidoEn
DomicilioFiscal UbicacionFiscal ubicacionFiscal
ExpedidoEn
Ubicación
Receptor
T_Rfc rfc String nombre Domicilio domicilio
Domicilio Ubicación
Conceptos List conceptos BigInteger sumaImportesConceptos //Atributo agregado por nosotros para guardar la suma total de los importes de los conceptos agregados
Concepto Double cantidad String unidad String noIdentificacion String descripción T_Importe valorUnitario T_Importe importe //cantidad * valorUnitario InformacionAduanera informacionAduanera CuentaPredial cuentaPredial ComplementoConcepto complementoConcepto Parte
InformacionAduanera T_InformacionAduanera
CuentaPredial Numero
ComplementoConcepto
// Nodo opcional donde se incluirán los nodos complementarios de extensión al concepto, definidos por el SAT, de acuerdo a disposiciones particulares a un sector o actividad específica.
Parte
Double cantidad String unidad String noIdentificacion String descripcion T_Importe valorUnitario T_Importe importe //cantidad * valorUnitario InformacionAduanera informacionAduanera
Impuestos T_Importe totalImpuestosRetenidos //Total de impuestos retenidos, obtenidos de los Conceptos T_Importe totalImpuestosTrasladados //Total de impuestos trasladados, obtenidos de los Conceptos Retenciones Traslados
Retenciones List retenciones T_Importe sumaImportesRetenciones // Atributo agregado por nosotros para guardar la suma total de los importes de las retenciones agregadas
Retencion String impuesto //ISR, IVA T_Importe importe
Traslados List traslados T_Importe sumaImportesTraslados // Atributo agregado por nosotros para guardar la suma total de los importes de los traslados agregados
Traslado String impuesto //IVA, IEPS T_Importe tasa T_Importe importe
Complemento TimbreFiscalDigital timbreFiscalDigital
Addenda
TIPOS COMPLEJOS T_Ubicacion String calle String noExterior String noInterior String colonia String localidad String referencia String municipio String estado String país String coidoPostal
T_UnicacionFiscal Mismos atributos que T_Ubicacion
T_InformacionAduanera String numero Date fecha String aduana
T_Rfc
String rfc //12 a 13 caracteres
T_Importe BigDecimal importe //Aquí usamos un BigDecimal, debido a que, por su exactitud, consideramos que es lo mejor para manejar cantidades de dinero
Algunas notas aclaratorias y recomendaciones:
Recomiendo comentar todas las clases, poniendo a cada una la descripción que se encuentra en los diagramas del Anexo 20 Usar BigDecimal para las unidades de dinero debido a que, según el API Java, es totalmente exacto En las clases de Conceptos, Retenciones y Traslados, agregar los atributos de sumaImportes* y sobreescribir el método del add de Java para que al momento de agregar un Concepto/Retencion/Traslado nos guarde la suma de los importe y no tener que hacer ciclos después que nos quitaran tiempo al generar el Comprobante Usar herencia para las siguientes clases: Ubicación, UbicacionFiscal, Domicilio, DomicilioFiscal,ExpedidoEn, tomando como clase padre a Ubicación ya que es la clase que no tiene ningún nodo requerido, y de ahí extender los demas
Fuente y sitios recomendados:
Anexo 20 paginas 55-76 http://www.google.com.mx/url?sa=t&source=web&cd=1&ved=0CBQQFjAA&url= ftp%3A%2F%2Fftp2.sat.gob.mx%2Fasistencia_servicio_ftp%2Fpublicaciones%2F anteproyectos%2FAnteproyecto_A20_03092010.doc&rct=j&q=anexo%2020%20v 3%20del%20sat&ei=Gz28TI3mG5CCsQPZlZzuDg&usg=AFQjCNGRtPPl8xCqSX AdiRD5Yo6BzUQS3w&sig2=k8508zZvokRiBatwzWv-qg&cad=rja – Anteproyecto del Anexo 20 V3 ftp://ftp2.sat.gob.mx/asistencia_servicio_ftp/publicaciones/legislacion10/a20rmf_23 092010.doc - Anexo 20 de la Primera Resolución de Modificaciones a la Resolución Miscelánea Fiscal para 2010, publicada el 14 de septiembre de 2010. Publicado en el DOF del 23 de septiembre de 2010 http://code.google.com/p/cx-faktura/ - Codigo java para generar un CFD versión2 http://www.facturae.es/ESES/DESCARGAS/DESCARGASDESARROLLO/Paginas/APIJava2.aspx - API JAVA para la generación de CFDs en España http://www.nic.cl/anuncios/2003-08-07.html - API JAVA para la generación de CFDs en Chile
PASO 2: Generar Cadena Original del CFDI SIN TimbreFiscalDigital
En este punto existen 2 opciones: 1.- Generar el xml del Comprobante de acuerdo al formato del Anexo 20 y a partir del xml generar la Cadena Original 2.- Generar “a mano” la Cadena Original y posteriormente el xml del Comprobante. Nosotros elegimos por razones de tiempo, generar “a mano” la cadena original. Esto lo
logramos de la siguiente manera: Cada clase u objeto se encarga de generar su propia cadena original de acuerdo al estándar publicado por el SAT, de tal manera que la clase Comprobante, solo tiene que concatenar al generar su propia cadena Original, todas las “cadenas originales” de los elementos que requiere.
Estos son los requisitos que deben cumplir la generación de la Cadena Original: Reglas Generales para la generación de la Cadena Original :
1. Ninguno de los atributos que conforman al comprobante fiscal digital deberá contener el carácter | (“pipe”) debido a que este será utilizado como carácter de control en la formación de la cadena original. 2. El inicio de la cadena original se encuentra marcado mediante una secuencia de caracteres || (doble “pipe”).
3. Se expresará únicamente la información del dato sin expresar el atributo al que hace referencia. Esto es, si la serie del comprobante es la “A” so lo se expresará |A| y nunca |Serie A|. 4. Cada dato individual se encontrará separado de su dato subsiguiente, en caso de existir, mediante un carácter | (“pipe” sencillo). 5. Los espacios en blanco que se presenten dentro de la cadena original serán tratados de la siguiente manera: a. Se deberán remplazar todos los tabuladores, retornos de carro y saltos de línea por espacios en blanco. b. Acto seguido se elimina cualquier carácter en blanco al principio y al final de cada separador | (“pipe” sencillo). c. Finalmente, toda secuencia de caracteres en blanco intermedias se sustituyen por un único carácter en blanco. 6. Los datos opcionales no expresados, no aparecerán en la cadena original y no tendrán delimitador alguno. 7. El final de la cadena original será expresado mediante una cadena de caracteres || (doble “pipe”).
8. Toda la cadena de original se expresará en el formato de codificación UTF-8. 9. El nodo o nodos adicionales se integrarán a la cadena original como se indica en la secuencia de formación en su numeral 10, respetando la secuencia de formación y número de orden del ComplemetoConcepto. 10. El nodo o nodos adicionales se integraran al final de la cadena original respetando la secuencia de formación para cada complemento y número de orden del Complemento. 11. El nodo Timbre Fiscal Digital del SAT será integrado posterior a la validación realizada por un proveedor autorizado por el SAT que forma parte de la Certificación Digital del SAT. Dicho nodo no se integrará a la formación de la cadena original del CFDI, las reglas de conformación de la cadena original del nodo se describen en el rubro II.C del presente anexo. Y la Secuencia de Formación para la Cadena Original es esta: Secuencia de Formación de la Cadena Original
1. Información del nodo Comprobante a. version b. fecha c. tipoDeComprobante d. formaDePago e. condicionesDePago f. subTotal g. descuento h. TipoCambio i. Moneda j. total 2. Información del nodo Emisor a. rfc b. nombre
3. Información del nodo DomicilioFiscal a. calle b. noExterior c. noInterior d. colonia e. localidad f. referencia g. municipio h. estado i. pais j. codigoPostal 4. Información del nodo ExpedidoEn a. calle b. noExterior c. noInterior d. colonia e. localidad f. referencia g. municipio h. estado i. pais j. codigoPostal 5. Información del nodo Receptor a. rfc b. nombre 6. Información del nodo Domicilio a. calle b. noExterior c. noInterior d. colonia e. localidad f. referencia g. municipio h. estado i. pais j. codigoPostal 7. Información de cada nodo Concepto nota: esta secuencia deberá ser repetida por cada nodo Concepto relacionado a. cantidad b. unidad c. noIdentificacion d. descripcion e. valorUnitario f. importe g. InformacionAduanera nota: esta secuencia deberá ser repetida por cada nodo InformacionAduanera de forma indistinta a su grado de dependencia i. numero
ii. fecha iii. aduana h. Información del nodo CuentaPredial i. numero 8. Información del nodo ComplementoConcepto de acuerdo con lo expresado en el Rubro III.B. 9. Información de cada nodo Retencion nota: esta secuencia a, b, deberá ser repetida por cada nodo Retención relacionado, el total de impuestos retenidos no se repite. a. impuesto b. importe c. totalImpuestosRetenidos 10. Información de cada nodo Traslado nota: esta secuencia a, b, deberá ser repetida por cada nodo Traslado relacionado, el total de impuestos trasladados no se repite. a. Impuesto b. tasa c. importe d. totalImpuestosTrasladados 11. Información del nodo Complemento de acuerdo con lo expresado en el Rubro III.B. Ahora, muestro un ejemplo de la manera en que generamos la Cadena Original public class Comprobante{ private String versión = “3.0”;
. . . private Emisor emisor; public String getCadenaOriginal(){
String cadena = "||"; //inicio de la cadena original sdf = new SimpleDateFormat(Constants. DATE_FORMATO_CFDI ); //para formatear la fecha //Informacion del Nodo Comprobante cadena += version + "|" + sdf.format(fecha) + "|" + tipoDeComprobante + "|" + formaDePago + "|" + (!getCondicionesDePago().equals( "") ? condicionesDePago + "|" : "" ) + getSubtotal().getImporte().toString() + "|" + (!getDescuento().getImporte().toString().equals( "0.0") ? getDescuento().getImporte().toString() + "|" : "") + (!getTipoDeCambio().equals( "") ? getTipoDeCambio() + "|" : "") + (!getMoneda().equals( "") ? getMoneda() + "|" : "") + getTotal().getImporte().toString()+ "|"; //Informacion del Nodo Emisor (Domicilio Fiscal, ExpedidoEn) cadena += emisor.getCadenaOriginal() + "|"; //Informacion del Nodo Receptor (Domicilio)
cadena += receptor.getCadenaOriginal() + "|"; //Informacion del Nodo Conceptos cadena += conceptos.getCadenaOriginal() + "|"; //Informacion del Nodo Impuestos //Informacion del Nodo Retenciones cadena += impuestos.getRetenciones().getCadenaOriginal() + "|"; //Informacion del Nodo Traslados cadena += impuestos.getCadenaOriginalTraslados(); //Informacion del Nodo Complemento cadena += "||"; try{
cadena = new String(cadena.getBytes( "UTF-8")); //Codificacion de la Cadena a UTF-8 } catch(UnsupportedEncodingException uee){ System. out.println("Error al codificar la cadena a UTF8"); } return cadena;
} }
public class Emisor { private T_Rfc rfc; private String nombre; private DomicilioFiscal domicilioFiscal ; private ExpedidoEn expedidoEn; public String getCadenaOriginal() {
String cadena = ""; //Informacion del Nodo Emisor cadena += this.rfc.getCadenaOriginal() + "|" + nombre; //Informacion del Nodo Domicilio Fiscal if(domicilioFiscal != null && !domicilioFiscal .getCadenaOriginal().equals( "")){ cadena += "|" + domicilioFiscal.getCadenaOriginal(); } //Informacion del Nodo ExpedidoEn if(expedidoEn != null && !expedidoEn.getCadenaOriginal().equals( "")){ cadena += "|" + expedidoEn.getCadenaOriginal(); } return cadena;
}
} public class T_Rfc { private String rfc; public String getCadenaOriginal(){ //Regresa la Cadena Original del
rfc return this.rfc;
} }
Algunas notas aclaratorias y recomendaciones:
Los elementos que son REQUERIDOS el Comprobante no necesariamente son requeridos por la Cadena Original. Los elementos REQUERIDOS por la Cadena Original algunos son OPCIONALES en el Comprobante. Por lo tanto, los elementos OPCIONALES que no se encuentren el Comprobante, NO APARECERAN en la Cadena Original. Notese en el ejemplo anterior, en el elemento Comprobante, que la Cadena Original se regresa ya codificada en el formato UTF-8, el cual es el estándar establecido por el Anexo 20
Fuente y sitios recomendados:
Anexo 20 paginas 95-97 http://code.google.com/p/cx-faktura/ - Codigo java para generar un CFD versión2.
PASO 3: Generar Sello Digital
A continuación se describe el procedimiento para la generación del Sello Digital tal y como lo describe el Anexo 20 del SAT. Hay que recordar que la generación del “sello digital” no es más que aplicar una serie de algoritmos a la Cadena Original, que convertirán a esta en una cadena encriptada y es este resultado, lo que conocemos como “sello digital”, al igual que un Comprobante “sellado”, es un Comprobante que contiene un cadena original que ya ha sido procesada con los algoritmos necesarios y convertida en el atributo “sello” del
Comprobante.
Procedimiento
En pasos sencillos, el procedimiento es este: I. Obtener la Cadena Original II. Aplicar el método de digestión SHA-1 a la Cadena Original (por ahora no hay nodos Complementarios asi que no nos causaran problemas ya que no se toman en cuenta) III. Encriptar el resultado obtenido en el paso anterior usando el algoritmo de encriptación RSA, usando para ello la Clave Privada correspondiente al Certificado Digital del Emisor del Mensaje y Sello Digital (certificado y llave del certificado) IV. El resultado obtenido en el paso anterior, codificarlo a Base 64 (consiste en la asociación de cada 6 bits de la secuencia a un elemento de un "alfabeto" que consta de 64 caracteres imprimibles) Aquí un ejemplo de Sello Digital: GqDiRrea6+E2wQhqOCVzwME4866yVEME/8PD1S1g6AV48D8VrLhKUDq0Sjqnp9Iwf MAbX0ggwUCLRKa+Hg5q8aYhya63If2HVqH1sA08poer080P1J6Z+BwTrQkhcb5Jw8jE NXoErkFE8qdOcIdFFAuZPVT+9mkTb0Xn5Emu5U8= Tal y como lo describe el SAT, el procedimiento es este: Para toda cadena original a ser sellada digitalmente, la secuencia de algoritmos a aplicar es la siguiente: I. Aplicar el método de digestión SHA-1 a la cadena original a sellar incluyendo los nodos Complementarios. Este procedimiento genera una salida de 160 bits (20 bytes) para todo mensaje. La posibilidad de encontrar dos mensajes distintos que produzcan una misma salida es de 1 en 2160, y por lo tanto en esta posibilidad se basa la inalterabilidad del sello, así como su no reutilización. Es de hecho una medida de la integridad del mensaje sellado, pues toda alteración del mismo provocará una digestión totalmente diferente, por lo que no se podrá autentificar el mensaje. SHA-1 no requiere semilla alguna. El algoritmo cambia su estado de bloque en bloque de acuerdo a la entrada previa. II. Con la clave privada correspondiente al certificado digital del emisor del mensaje y del sello digital, encriptar la digestión del mensaje obtenida en el paso I utilizando para ello el algoritmo de encripción RSA. Nota: La mayor parte del software comercial podría generar los pasos I y II invocando una sola función y especificando una constante simbólica. En el SAT este procedimiento se hace en pasos separados, lo cual es totalmente equivalente. Es importante resaltar que prácticamente todo el software criptográfico comercial incluye APIs o expone métodos en sus productos que permiten implementar la secuencia de algoritmos aquí descrita. La clave privada solo debe mantenerse en memoria durante la llamada a la función de encripción; inmediatamente después de su uso debe ser eliminada de
III.
su registro de memoria mediante la sobre escritura de secuencias binarias alternadas de "unos" y "ceros". El resultado será una cadena binaria que no necesariamente consta de caracteres imprimibles, por lo que deberá traducirse a una cadena que sí conste solamente de tales caracteres. Para ello se utilizará el modo de expresión de secuencias de bytes denominado "Base 64", que consiste en la asociación de cada 6 bits de la secuencia a un elemento de un "alfabeto" que consta de 64 caracteres imprimibles. Puesto que con 6 bits se pueden expresar los números del 0 al 63, si a cada uno de estos valores se le asocia un elemento del alfabeto se garantiza que todo byte de la secuencia original puede ser mapeado a un elemento del alfabeto Base 64, y los dos bits restantes formarán parte del siguiente elemento a mapear. Este mecanismo de expresión de cadenas binarias produce un incremento de 25% en el tamaño de las cadenas imprimibles respecto de la original. La codificación en base 64, así como su decodificación, se hará tomando los bloques a procesar en el sentido de su lectura, es decir, de izquierda a derecha. El alfabeto a utilizar se expresa en el siguiente catálogo
A continuación la manera en la que generamos el Sello Digital public class GeneradorSelloDigital { public String getSelloDigital(String cadenaOriginal) throws GeneralSecurityException{ Security.addProvider( new BouncyCastleProvider()); //Esta es la manera en la que se añade el Wrapper de BouncyCastle para hacer la encriptacion. Lo que hace esta línea es que se usen las clases del paquete Security de BouncyCastle en lugar de las de Java originales System. out.println("Cadena Original "+cadenaOriginal); FileInputStream archivoClavePrivada= null; try{ archivoClavePrivada= new FileInputStream( "Path_del_archivo_emisor.key" ); }catch(FileNotFoundException fnfe){ fnfe.printStackTrace(); } String password="claveDelArchivo" ; byte [] clavePrivada = getBytes(archivoClavePrivada); PKCS8Key pkcs8 = new PKCS8Key(clavePrivada,
password.toCharArray()); PrivateKey pk = pkcs8.getPrivateKey(); Signature firma = Signature. getInstance ("SHA1withRSA"); //Aplicacion de la Digestion con SHA-1 y encriptado a con RSA en un solo paso firma.initSign(pk); String selloDigital = null; try { firma.update(cadenaOriginal.getBytes( "UTF-8")); //Codificacion del resultado a UTF-8 BASE64Encoder b64 = new BASE64Encoder(); selloDigital = b64.encode(firma.sign()); //Conversion del resultado anterior a Base64
} catch (UnsupportedEncodingException e) { e.printStackTrace(); } System. out.println("Sello Digital "+selloDigital); return selloDigital; } /** * Metodo que convierte un input stream con la llave privada a un array de bytes * @param is InputSteam con la clave privada * @return Arreglo de bytes con la clave privada */ private byte [] getBytes(InputStream is) { int totalBytes = 714; byte[] buffer = null; try { buffer = new byte[totalBytes]; is.read(buffer, 0, totalBytes); is.close(); } catch (IOException e) { e.printStackTrace(); } return buffer; } }
Algunas notas aclaratorias y recomendaciones:
Al parecer, las únicas librerías aceptadas por el SAT para la generación de la firma digital son: Open SSL y BouncyCastle, el cual cuenta con un Wrapper para Java, que es lo que nosotros usamos Una vez generado el Sello Digital, deberemos asignarlo en los siguientes lugares: I. En el Comprobante, en el atributo “sello” II. En el Nodo de Complemento Timbre Fiscal, en el atributo “selloCFD”
Fuente y sitios recomendados:
Anexo 20 paginas 97-98 NOTA: Todos los links ftp del SAT deben abrirse con Internet Explorer ftp://ftp2.sat.gob.mx/asistencia_servicio_ftp/publicaciones/solcedi/Certif_PACyEmi sor.zip - Certificado PAC y Emisor http://www.javamexico.org/blogs/nopalin/facturacion_electronica - Encriptación y codificación a Base 64, pero usando MD5 (usado en los CFD v2) http://uetiko-developer.blogspot.com/2010/02/como-obtener-el-sello-digital-con java.html -Obtención del Sello Digital en una sola Clase totalmente comentada, pero usando MD5 http://es.debugmodeon.com/articulo/generar-hash-sha-1-de-una-cadena-en-java Generación del Hash SHA-1 con Java
http://renetrejo.blogspot.com/2007/11/facturacin-electrnica.html - Generacion Sello Digital usando MD5 con Java http://www.sat.gob.mx/sitio_internet/e_sat/comprobantes_fiscales/15_6522.html OpenSSL y BouncyCastle, son las unicas opciones que muestra el SAT para generar el Sello http://www.validacfd.com/phpbb3/viewtopic.php?f=5&t=34 OpenSSL y Java no firman igual http://www.bouncycastle.org Sitio oficial Bouncy Castle http://www.openssl.org Sitio Oficial Open SSL
PASO 4: Generar y validar XML del Comprobante
En este paso, nosotros hicimos uso JDOM, que es una biblioteca de código abierto para manipulaciones de datos XML optimizados para Java. Esta es la manera en la que logramos generar el XML: public class CrearXML { protected Locale local = new java.util.Locale
(Constants.LOCALE_LANGUAGE, Constants.LOCALE_COUNTRY, Constants.LOCALE_VARIANT); private SimpleDateFormat sdf = new SimpleDateFormat (Constants.DATE_FORMATO_CFDI, local); private Document xml=new Document(); private Element root; /** * Este metodo genera el Elemento Comprobante del XML * @param comprobante */ public void generaRaiz(Comprobante comprobante) { //crea un elemento raiz y le asigna los namespaces y los xsd root = new Element(Constants.COMPROBANTE_COMPROBANTE,Constants.COMPROBANTE_PREFIX_NA MESPACE,Constants.COMPROBANTE_NAMESPACE_URI); //root = new Element(Constants.COMPROBANTE_COMPROBANTE,Constants.COMPROBANTE_NAMESPACE _URI); Namespace namespace=Namespace.getNamespace(Constants.COMPROBANTE_PREFIX, Constants.COMPROBANTE_URI_PREFIX); root.setAttribute(Constants.COMPROBANTE_SCHEMA,Constants.COMPROBANTE_SCHE MA_XSD,namespace); root.addNamespaceDeclaration(namespace); //se empieza a construir el comprobante root.setAttribute(Constants.COMPROBANTE_VERSION, Constants.VERSION_COMPROBANTE_TRES);
if(comprobante.getSerie()!= null&&!comprobante.getSerie().trim().equals( ""
)){ root.setAttribute(Constants.COMPROBANTE_SERIE, comprobante.getSerie()); } if(comprobante.getFolio()!= null&&!comprobante.getFolio().trim().equals( ""
)){ root.setAttribute(Constants.COMPROBANTE_FOLIO, comprobante.getFolio()); } root.setAttribute(Constants.COMPROBANTE_FECHA, sdf.format(comprobante.getFecha())); root.setAttribute(Constants.COMPROBANTE_SELLO, comprobante.getSello()); . . . //se generan el Nodo Emisor generaEmisor(comprobante.getEmisor()); generaReceptor(comprobante.getReceptor()); generaConceptos(comprobante.getConceptos()); generaImpuestos(comprobante.getImpuestos()); getXml().setRootElement(root); } public void generaEmisor(Emisor emisor) {
//se le agrega el namespace al emisor Element emisorElement = new Element(Constants.COMPROBANTE_EMISOR,Constants.COMPROBANTE_PREFIX_NAMESPA CE,Constants.COMPROBANTE_NAMESPACE_URI); emisorElement.setAttribute(Constants.COMPROBANTE_RFC, emisor.getRfc().getRfc()); emisorElement.setAttribute(Constants.COMPROBANTE_NOMBRE, emisor.getNombre()); //se crea el nodo domiciliofiscal Element domicilioFiscal = new Element(Constants.COMPROBANTE_DOMICILIO_FISCAL,Constants.COMPROBANTE_PREF IX_NAMESPACE,Constants.COMPROBANTE_NAMESPACE_URI); domicilioFiscal.setAttribute(Constants.COMPROBANTE_DOMICILIO_GENERICO_CAL LE, emisor.getDomicilioFiscal().getCalle()); if(emisor.getDomicilioFiscal().getNoExterior()!= null&&!emisor.getDomicili
oFiscal().getNoExterior().trim().equals( "")){ domicilioFiscal.setAttribute(Constants.COMPROBANTE_DOMICILIO_GENERICO_NO_ EXTERIOR, emisor.getDomicilioFiscal().getNoExterior()); } if(emisor.getDomicilioFiscal().getNoInterior()!= null&&!emisor.getDomicili
oFiscal().getNoInterior().trim().equals( "")){ domicilioFiscal.setAttribute(Constants.COMPROBANTE_DOMICILIO_GENERICO_NO_ INTERIOR, emisor.getDomicilioFiscal().getNoInterior());
} . . . domicilioFiscal.setAttribute(Constants.COMPROBANTE_DOMICILIO_GENERICO_MUN ICIPIO, emisor.getDomicilioFiscal().getMunicipio()); domicilioFiscal.setAttribute(Constants.COMPROBANTE_DOMICILIO_GENERICO_EST ADO, emisor.getDomicilioFiscal().getEstado()); . . . //se agrega el domicilio fiscal al nodo emisor emisorElement.addContent(domicilioFiscal); //se agrega el nodo emisor al elemento comprobante root.addContent(emisorElement); } public void generaReceptor(Receptor receptor) {
//se crea el nodo receptor Element rec = new Element(Constants.COMPROBANTE_RECEPTOR,Constants.COMPROBANTE_PREFIX_NAMES PACE,Constants.COMPROBANTE_NAMESPACE_URI); rec.setAttribute(Constants.COMPROBANTE_RFC, receptor.getRfc().getRfc()); if(receptor.getNombre()!= null&&!receptor.getNombre().trim().equals( "")){
rec.setAttribute(Constants.COMPROBANTE_NOMBRE, receptor.getNombre()); } //se crea el nodo domicilio Element domicilio = new Element(Constants.COMPROBANTE_DOMICILIO,Constants.COMPROBANTE_PREFIX_NAME SPACE,Constants.COMPROBANTE_NAMESPACE_URI); if(receptor.getDomicilio().getCalle()!= null&&!receptor.getDomicilio().get
Calle().trim().equals( "")){ domicilio.setAttribute(Constants.COMPROBANTE_DOMICILIO_GENERICO_CALLE, receptor.getDomicilio().getCalle()); } if(receptor.getDomicilio().getNoExterior()!= null&&!receptor.getDomicilio(
).getNoExterior().trim().equals( "")){ domicilio.setAttribute(Constants.COMPROBANTE_DOMICILIO_GENERICO_NO_EXTERI OR, receptor.getDomicilio().getNoExterior()); } . . . //se agrega el domicilio al receptor rec.addContent(domicilio); //se agrega el nodo receptor al comprobante root.addContent(rec);
} public void generaConceptos(Conceptos concp) { Element conceptos = new
Element(Constants.COMPROBANTE_CONCEPTOS,Constants.COMPROBANTE_PREFIX_NAME SPACE,Constants.COMPROBANTE_NAMESPACE_URI); for (Concepto con : concp) { Element concepto = new Element(Constants.COMPROBANTE_CONCEPTO,Constants.COMPROBANTE_PREFIX_NAMES PACE,Constants.COMPROBANTE_NAMESPACE_URI); concepto.setAttribute(Constants.COMPROBANTE_CONCEPTO_CANTIDAD, con.getCantidad().toString()); if(con.getUnidad()!= null&&!con.getUnidad().trim().equals( "")){
concepto.setAttribute(Constants.COMPROBANTE_CONCEPTO_UNIDAD, con.getUnidad()); } if(con.getNoIdentificacion()!= null&&!con.getNoIdentificacion().trim().equ
als("")){ concepto.setAttribute(Constants.COMPROBANTE_CONCEPTO_NO_IDENTIFICACION, con.getNoIdentificacion()); } concepto.setAttribute(Constants.COMPROBANTE_CONCEPTO_DESCRIPCION, con.getDescripcion()); concepto.setAttribute(Constants.COMPROBANTE_CONCEPTO_VALOR_UNITARIO, con.getValorUnitario().getImporte().toString()); concepto.setAttribute(Constants.COMPROBANTE_CONCEPTO_IMPORTE, con.getImporte().getImporte().toString()); //checar los nodos opcionales de conceptos InformacionAduanera,CuentaPredial,ComplementoConcepto,Parte conceptos.addContent(concepto); } root.addContent(conceptos); } public void generaImpuestos(Impuestos imp){
//checar los elementos de impuestos Element impuestos= new Element(Constants.COMPROBANTE_IMPUESTOS, Constants.COMPROBANTE_PREFIX_NAMESPACE,Constants.COMPROBANTE_NAMESPACE_UR I); root.addContent(impuestos); } public boolean creaAndValidaXML(Comprobante comprobante){ boolean response= false;
generaRaiz(comprobante); //Instancia La clase que da la salida XML al archivo XMLOutputter outputter = new XMLOutputter(); //Formato XML Arreglado Con Identacion Format formato = Format.getPrettyFormat(); outputter.setFormat(formato); //Crea el archivo aunque no de manera logica
File archivoXml = new File("/home/eder/comprobante.xml" ); try { //se instancia la clase que va a escrbir el archivo en disco Writer write = new FileWriter(archivoXml); //se escribe el archivo en disco outputter.output(getXml(),write); } catch (IOException e) { System. err .println(e); } //se instancia la clase que validara el XSD SAXBuilder builder = new SAXBuilder("org.apache.xerces.parsers.SAXParser" , true); builder.setFeature( "http://apache.org/xml/features/validation/schema" , true); builder.setFeature( "http://apache.org/xml/features/validation/schemafull-checking", true); builder.setProperty( "http://apache.org/xml/properties/schema/externalschemaLocation", Constants.COMPROBANTE_SCHEMA_XSD); builder.setValidation( true); //se imprime el documento si se logro cumplir con el XSD try { Document document = builder.build(archivoXml); outputter.output(document, System. out); response= true; } catch (JDOMException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } return response; } /** * @return the xml */ public Document getXml() { return xml; } }
A continuación muestro las Constantes con sus valores que usamos //Comprobante Fiscal Digital-START public static final String COMPROBANTE_COMPROBANTE = "Comprobante"; public static final String COMPROBANTE_VERSION = "version"; public static final String COMPROBANTE_NUM_VERSION = "3.0"; public static final String COMPROBANTE_FOLIO = "folio"; public static final String COMPROBANTE_SERIE = "serie"; public static final String COMPROBANTE_FECHA = "fecha"; public static final String COMPROBANTE_SELLO = "sello"; public static final String COMPROBANTE_NO_CERTIFICADO = "noCertificado"; public static final String COMPROBANTE_CERTIFICADO = "certificado";
public static final String COMPROBANTE_CONDICIONES_PAGO =
"condicionesDePago" ; public static final String COMPROBANTE_SUBTOTAL = "subTotal"; public static final String COMPROBANTE_DESCUENTO = "descuento"; public static final String COMPROBANTE_MOTIVO_DESCUENTO =
"motivoDescuento" ; public public public public
static static static static
final final final final
String String String String
COMPROBANTE_TIPO_CAMBIO = "TipoCambio"; COMPROBANTE_MONEDA = "Moneda"; COMPROBANTE_TOTAL = "total"; COMPROBANTE_NO_APROBACION =
"noAprobacion"; public static final String COMPROBANTE_ANO_APROBACION =
"anoAprobacion"; public static final String COMPROBANTE_FORMA_PAGO = "formaDePago"; public static final String COMPROBANTE_METODO_DE_PAGO =
"metodoDePago"; public static final String COMPROBANTE_TIPO_COMPROBANTE =
"tipoDeComprobante" ; public static final Integer NUMERO_DECIMALES_IMPORTE = 6; public static final String VERSION_COMPROBANTE_TRES = "3.0"; public static final String COMPROBANTE_RFC = "rfc"; public static final String COMPROBANTE_NOMBRE = "nombre";
//Emisor public static final String COMPROBANTE_EMISOR = "Emisor";
//Receptor public static final String COMPROBANTE_RECEPTOR = "Receptor";
//Domicilios public static final String COMPROBANTE_DOMICILIO_FISCAL =
"DomicilioFiscal" ; public static final String COMPROBANTE_DOMICILIO = "Domicilio";
//DomicilioGenerico public static final String COMPROBANTE_DOMICILIO_GENERICO_CALLE =
"calle"; public static final String COMPROBANTE_DOMICILIO_GENERICO_NO_EXTERIOR
= "noExterior"; public static final String COMPROBANTE_DOMICILIO_GENERICO_NO_INTERIOR
= "noInterior"; public static final String COMPROBANTE_DOMICILIO_GENERICO_COLONIA =
"colonia"; public static final String COMPROBANTE_DOMICILIO_GENERICO_PAIS =
"pais"; public static final String COMPROBANTE_DOMICILIO_GENERICO_CODIGO_POSTAL = "codigoPostal"; public static final String COMPROBANTE_DOMICILIO_GENERICO_ESTADO =
"estado"; public static final String COMPROBANTE_DOMICILIO_GENERICO_REFERENCIA
= "referencia"; public static final String COMPROBANTE_DOMICILIO_GENERICO_LOCALIDAD =
"localidad"; public static final String COMPROBANTE_DOMICILIO_GENERICO_MUNICIPIO =
"municipio"; //DomicilioGenerico //Conceptos
public static final String COMPROBANTE_CONCEPTOS = "Conceptos"; public static final String COMPROBANTE_CONCEPTO = "Concepto"; public static final String COMPROBANTE_CONCEPTO_CANTIDAD =
"cantidad"; public static final String COMPROBANTE_CONCEPTO_UNIDAD = "unidad"; public static final String COMPROBANTE_CONCEPTO_NO_IDENTIFICACION =
"noIdentificacion" ; public static final String COMPROBANTE_CONCEPTO_DESCRIPCION =
"descripcion"; public static final String COMPROBANTE_CONCEPTO_VALOR_UNITARIO =
"valorUnitario"; public static final String COMPROBANTE_CONCEPTO_IMPORTE = "importe"; public static final String COMPROBANTE_NAMESPACE_URI =
"http://www.sat.gob.mx/cfd/3" ; //Impuestos public static final String COMPROBANTE_IMPUESTOS = "Impuestos"; public static final String COMPROBANTE_IMPUESTOS_TOTAL_IMPUESTOS = "totalImpuestosTrasladados" ; //NameSpaces public static final String COMPROBANTE_PREFIX = "xsi"; public static final String COMPROBANTE_PREFIX_NAMESPACE = "cfdi"; public static final String COMPROBANTE_URI_PREFIX = "http://www.w3.org/2001/XMLSchema-instance" ; public static final String COMPROBANTE_SCHEMA = "schemaLocation" ; public static final String COMPROBANTE_SCHEMA_XSD = "http://www.sat.gob.mx/cfd/3 http://www.sat.gob.mx/sitio_internet/cfd/3/cfdv3.xsd" ; //TimbreFiscal-START http://www.sat.gob.mx/cfd/3 public static final String COMPROBANTE_TIMBRE_FISCAL = "TimbreFiscalDigital" ; public static final String VERSION_TIMBRE_FISCAL = "2.0"; public static final String COMPROBANTE_TIMBRE_FISCAL_UUID = "UUID"; public static final String COMPROBANTE_TIMBRE_FISCAL_FECHA_TIMBRADO = "FechaTimbrado"; public static final String COMPROBANTE_TIMBRE_FISCAL_SELLO_CFD = "selloCFD"; public static final String COMPROBANTE_TIMBRE_FISCAL_NO_CERTIFICADO_SAT = "noCertificadoSAT" ; public static final String COMPROBANTE_TIMBRE_FISCAL_SELLO_SAT = "selloSAT"; //TimbreFiscal-END //Encriptacion-START public static final String ALGORITMO_DIGESTION_AND_CIFRADO = "SHA1withRSA";
Algunas notas aclaratorias y recomendaciones:
El archivo no esta completo. Se omitieron ciertas partes que se considera son repetitivas, al igual que explicar línea a línea el código seria muy “pesado”; por eso mostramos el código usado con sus respectivos comentarios, con la esperanza que sea entendible para quien lo lea. Recomendamos el uso de Constantes para los Namespaces y para las demás constantes.
Nótese el uso de la clase java SimpleDateFormat, la cual es usada para dar formato a las fechas, siendo para ello el formato establecido por el SAT: ISO 1801, la cual queda de esta manera: new SimpleDateFormat( "yyyy-MM-dd'T'HH:mm:ss" ); Notese el método creaAndValidaXML, que es el método en el cual se genera el archivo XML y se graba en el disco duro y al mismo tiempo se valida contra el XSD proveido por el SAT Nótese todas las validaciones hechas. Si el atributo es requerido se añade por default a la generación del XML, si no lo es, se valida si esta rellenado ese atributo; si lo está, se añade al XML y si no, se ignora. En este paso se ha creado solamente el XML del Comprobante SIN TimbreFiscalDigital debido a que el SAT provee 2 archivos XSD. Uno para el CFD (Sin Timbre Fiscal Digital) y otro solo para el Timbre Fiscal Digital.
Fuente y sitios recomendados:
ftp://ftp2.sat.gob.mx/asistencia_servicio_ftp/publicaciones/solcedi/cfdv3.xsd - XSD para el Comprobante SIN Timbre Fiscal Digital ftp://ftp2.sat.gob.mx/asistencia_servicio_ftp/publicaciones/solcedi/TimbreFiscalDig ital.xsd - XSD para el Timbre Fiscal Digital
PASO 5: Generar Cadena Original del Timbre Fiscal Digital
Este es el orden de los elementos que se integraran a la Cadena Original del Timbre Fiscal Digital, tomado del Anexo 20. Recordar que la cadena debe estar codificada con UTF-8: “La secuencia de formación será siempre en el orden que se expresa a continuación,
tomando en cuenta las reglas generales expresadas en el párrafo anterior. a. Atributos del elemento raíz TimbreFiscalDigital 1. version 2. UUID 3. FechaTimbrado 4. selloCFD 5. noCertificadoSAT”
Ejemplo de cadena original de un timbre:
||1.0|ad662d33-6934-459c-a128-bdf0393e0f44|2001-1217T09:30:47Z|iYyIk1MtEPzTxY3h57kYJnEXNae9lvLMgAq3jGMePsDtEOF6XLWbrV2 GL/2TX00vP2+YsPN+5UmyRdzMLZGEfESiNQF9fotNbtA487dWnCf5pUu0ikVpgHvpY 7YoA4lB1D/JWc+zntkgW+Ig49WnlKyXi0LOlBOVuxckDb7EAx4=|12345678901234 567890||
“Nota: El atributo selloCFD será el sello previo del Comprobante Fiscal Digital, el sello del
timbre será guardado dentro del atributo selloSAT. Esta cadena original será sellada utilizando el algoritmo de digestión SHA-1.” Ahora, bien, hasta donde hemos logrado comprender, el Timbre Fiscal Digital se añadirá al Comprobante, como un elemento del elemento Complemento (No ComplementoConcepto). Los únicos atributos que deberán estar rellenados en el TimbreFiscalDigital son: “versión”, y “selloCFD”. Los demás elementos serán rellenados por el SAT cuando haga la validación de nuestro CFDI (se entiende que el CFDI se enviara al SAT por internet). “El resultado de la validación de un CFDI, asignación de un folio fiscal e incorporación del
sello digital del SAT se entenderá como el Timbrado Fiscal Digital. El folio fiscal digital será referido como el UUID. Para integrar el complemento TimbreFiscalDigital a un comprobante fiscal digital por Internet, la estructura resultante deberá integrarse como un nodo hijo del nodo Comprobante/Complemento/TimbreFiscalDigital. Adicional a su inclusión, se deberá definir el namespace correspondiente dentro del nodo Comprobante, así como referenciar la ubicación pública del esquema XSD correspondiente”. Fuente y sitios recomendados:
Anexo 20 página 103 Anexo 20, pagina 104 – Explicación de los namespaces del Timbre Fiscal Digital
PASO 6: Generar y validar XML del Timbre Fiscal Digital
Una vez que el CFDI ha sido validado por el SAT y EL Timbre Fiscal Digital ha sido rellenado con los campos de “uuid”, “selloSAT”, “fechaTimbrado” y “noCertificadoSAT”,
toca el momento de generar el XML del Timbre Fiscal Digital, el cual se generara y validara de la misma forma que el del Comprobante. Fuente y sitios recomendados:
ftp://ftp2.sat.gob.mx/asistencia_servicio_ftp/publicaciones/solcedi/TimbreFiscalDig ital.xsd -XSD para el Timbre Fiscal Digital
PASO 7: Juntar (concatenar) el XML obtenido del Comprobante + XML del TimbreFiscalDigital
Como ultimo paso, se juntara en un solo archivo el XML del Comprobante y el XML del Timbre Fiscal Digital y se tendrá un solo archivo que es en si nuestra “Factura” o “Comprobante Fiscal Digital por Internet”.
Fuente y sitios recomendados:
ftp://ftp2.sat.gob.mx/asistencia_servicio_ftp/publicaciones/solcedi/ejemplo1%20cfd v3.xml – Ejemplo oficial del SAT de un CFDI http://www.sat.gob.mx/sitio_internet/asistencia_contribuyente/principiantes/compro bantes_fiscales/66_19430.html - Utilerías del SAT para los CFDI
OTROS
Sobre el Uso de la Addenda: http://www.sat.gob.mx/sitio_internet/e_sat/comprobantes_fiscales/15_6601.html
