cosmemilton-acbr-node 0.1.2 → 0.2.0

package/docs/licenses/lazarus/COPYING.modifiedLGPL.txt

@@ -1,26 +1,26 @@
-This is the file COPYING.modifiedLGPL, it applies to several units in the
-Lazarus sources distributed by members of the Lazarus Development Team.
-All files contains headers showing the appropriate license. See there if this
-modification can be applied.
-
-These files are distributed under the Library GNU General Public License
-(see the file COPYING.LGPL) with the following modification:
-
-As a special exception, the copyright holders of this library give you
-permission to link this library with independent modules to produce an
-executable, regardless of the license terms of these independent modules,
-and to copy and distribute the resulting executable under terms of your choice,
-provided that you also meet, for each linked independent module, the terms
-and conditions of the license of that module. An independent module is a
-module which is not derived from or based on this library. If you modify this
-library, you may extend this exception to your version of the library, but
-you are not obligated to do so. If you do not wish to do so, delete this
-exception statement from your version.
-
-
-If you didn't receive a copy of the file COPYING.LGPL, contact:
-      Free Software Foundation, Inc.,
-      675 Mass Ave
-      Cambridge, MA  02139
-      USA
-
+This is the file COPYING.modifiedLGPL, it applies to several units in the
+Lazarus sources distributed by members of the Lazarus Development Team.
+All files contains headers showing the appropriate license. See there if this
+modification can be applied.
+
+These files are distributed under the Library GNU General Public License
+(see the file COPYING.LGPL) with the following modification:
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent modules,
+and to copy and distribute the resulting executable under terms of your choice,
+provided that you also meet, for each linked independent module, the terms
+and conditions of the license of that module. An independent module is a
+module which is not derived from or based on this library. If you modify this
+library, you may extend this exception to your version of the library, but
+you are not obligated to do so. If you do not wish to do so, delete this
+exception statement from your version.
+
+
+If you didn't receive a copy of the file COPYING.LGPL, contact:
+      Free Software Foundation, Inc.,
+      675 Mass Ave
+      Cambridge, MA  02139
+      USA
+

package/docs/licenses/lazarus/COPYING.txt

@@ -1,46 +1,46 @@
-This is the file COPYING. It gives an overview of the licenses used in the
-Lazarus sources.
-
-The Lazarus sources consists of several parts and each part has its own
-license. Three main licenses are in use:
-* the GNU General Public License, version 2 (GPLv2)
-* a modified LGPL (as described in COPYING.modifiedLGPL)
-* the MPL
-In general, each file contains a header, describing the license of the file.
-
-The license directory tree:
-
-<lazarus>/
- |
- +- ide             (GPLv2)
- |
- +- designer        (GPLv2)
- |
- +- debugger        (GPLv2)
- |
- +- examples        (GPLv2)
- |
- +- packager        (GPLv2)
- |
- +- tools           (GPLv2)
- |
- +- lcl             (modified LGPL)
- |                  With the exception of the customdrawn/android interface,
- |                  where some files are licensed under the
- |                  Apache Licence, Version 2.
- |
- +- components/
-    |
-    +- codetools    (GPLv2)
-    |
-    +- synedit      (MPL - Mozilla public license)
-    |
-    +- xxx There are various packages under various licenses. Mostly the
-           modified LGPL. See the license in the package files for details.
-           Some are not free for commercial use.
-           
-The IDE files are the files in the ide, designer, packager and debugger
-directory. They are under the GPLv2, with the following exceptions:
-transfermacros.pp, wordcompletion.pp, patheditordlg.pas, outputfilter.pas,
-inputfiledialog.pas, findreplacedialog.pp, findinfilesdlg.pas
-These files are under the modified LGPL as described in COPYING.modifiedLGPL.
+This is the file COPYING. It gives an overview of the licenses used in the
+Lazarus sources.
+
+The Lazarus sources consists of several parts and each part has its own
+license. Three main licenses are in use:
+* the GNU General Public License, version 2 (GPLv2)
+* a modified LGPL (as described in COPYING.modifiedLGPL)
+* the MPL
+In general, each file contains a header, describing the license of the file.
+
+The license directory tree:
+
+<lazarus>/
+ |
+ +- ide             (GPLv2)
+ |
+ +- designer        (GPLv2)
+ |
+ +- debugger        (GPLv2)
+ |
+ +- examples        (GPLv2)
+ |
+ +- packager        (GPLv2)
+ |
+ +- tools           (GPLv2)
+ |
+ +- lcl             (modified LGPL)
+ |                  With the exception of the customdrawn/android interface,
+ |                  where some files are licensed under the
+ |                  Apache Licence, Version 2.
+ |
+ +- components/
+    |
+    +- codetools    (GPLv2)
+    |
+    +- synedit      (MPL - Mozilla public license)
+    |
+    +- xxx There are various packages under various licenses. Mostly the
+           modified LGPL. See the license in the package files for details.
+           Some are not free for commercial use.
+           
+The IDE files are the files in the ide, designer, packager and debugger
+directory. They are under the GPLv2, with the following exceptions:
+transfermacros.pp, wordcompletion.pp, patheditordlg.pas, outputfilter.pas,
+inputfiledialog.pas, findreplacedialog.pp, findinfilesdlg.pas
+These files are under the modified LGPL as described in COPYING.modifiedLGPL.

package/docs/licenses/lazarus/ORIGIN.json

@@ -1 +1 @@
-{"version":"3.0","url":"https://gitlab.com/freepascal.org/lazarus/lazarus/-/tree/lazarus_3_0"}
+{"version":"3.0","url":"https://gitlab.com/freepascal.org/lazarus/lazarus/-/tree/lazarus_3_0"}

package/native/NativeMotor.pas

@@ -6,7 +6,7 @@ procedure Executar(Q,R:TJSONObject);
 implementation
 uses Classes,SysUtils,DateUtils,base64,ACBrNFe,ACBrDFeSSL,ACBrNFeNotasFiscais,
  ACBrDFe.Conversao,pcnConversao,pcnConversaoNFe,ACBrUtil.Strings,
- AcbrModels,NativeProtocol,NativeTLS,OpenSSLExt,ACBrDFeComum.RetEnvio,ACBrNFe.RetInut;
+ AcbrModels,NativeProtocol,NativeTLS,NativeRecovery,OpenSSLExt,ACBrDFeComum.RetEnvio,ACBrNFe.RetInut;
 procedure Estado(R:TJSONObject;const S:string);
 begin R.Strings['estado']:=S;R.Booleans['sucesso']:=not(S='ERRO')and not(S='REJEITADO')and not(S='PENDENTE')and not(S='INDETERMINADO')and not(S='DENEGADO');end;
 procedure ChaveValida(const Key:string;C:TJSONObject;M:TACBrNFe);
@@ -66,10 +66,26 @@ begin
  end;
 end;
 procedure CarregarXML(M:TACBrNFe;Q,C:TJSONObject;out XML:string);
+var OriginalKey,OriginalDocument,OriginalDigest:string;
 begin
  XML:=Decodificar(Texto(Q,'xmlBase64'),4*1024*1024);
  if(Pos('<!DOCTYPE',UpperCase(XML))>0)or(Pos('<!ENTITY',UpperCase(XML))>0)or(Pos(#0,XML)>0)or(Pos('<nfeProc',XML)>0)or(Pos('<enviNFe',XML)>0)then Falhar('XML_INVALIDO','Informe um XML NFe sem envelope, DTD ou entidades externas.');
- if not M.NotasFiscais.LoadFromString(XML,False)or(M.NotasFiscais.Count<>1)then Falhar('XML_INVALIDO','XML deve conter uma única NF-e 4.00.');
+ if Texto(Q,'comando')='recuperarXml'then begin
+  { Collection.LoadFromString in the pinned source searches literal NFe tags.
+    Its individual DOM reader supports namespaces; validate the exact root
+    first, then load it directly without rewriting any signed source bytes. }
+  try
+   OriginalKey:=ChaveAlvoRecuperacao(XML);
+   InspecionarAlvoRecuperacao(XML,OriginalKey,OriginalDocument,OriginalDigest);
+  except
+   on E:EFiscal do begin
+    if E.Codigo='RETORNO_INVALIDO'then Falhar('XML_INVALIDO','XML deve conter uma unica NFe assinada sem envelope.');
+    raise;
+   end;
+  end;
+  if not M.NotasFiscais.Add.LerXML(XML)or(M.NotasFiscais.Count<>1)then Falhar('XML_INVALIDO','XML deve conter uma unica NF-e 4.00.');
+  if M.NotasFiscais.Items[0].NumID<>OriginalKey then Falhar('IDENTIDADE_DIVERGENTE','Leitura da NFe diverge da identidade original.');
+ end else if not M.NotasFiscais.LoadFromString(XML,False)or(M.NotasFiscais.Count<>1)then Falhar('XML_INVALIDO','XML deve conter uma única NF-e 4.00.');
  Identidade(M,C);ChaveValida(M.NotasFiscais.Items[0].NumID,C,M);
  with M.NotasFiscais.Items[0].NFe.Ide do if(StrToIntDef(Copy(M.NotasFiscais.Items[0].NumID,23,3),-1)<>serie)or(StrToIntDef(Copy(M.NotasFiscais.Items[0].NumID,26,9),-1)<>nNF)or(Copy(M.NotasFiscais.Items[0].NumID,35,1)<>'1')or(StrToIntDef(Copy(M.NotasFiscais.Items[0].NumID,36,8),-1)<>cNF)then Falhar('IDENTIDADE_DIVERGENTE','Chave fiscal divergente dos dados do documento.');
  if(Texto(Q,'chave',False)<>'')and(Texto(Q,'chave')<>M.NotasFiscais.Items[0].NumID)then Falhar('IDENTIDADE_DIVERGENTE','Chave do XML divergente.');
@@ -78,6 +94,14 @@ procedure Schema(M:TACBrNFe);
 begin
  try M.NotasFiscais.Validar;except Falhar('XML_SCHEMA_INVALIDO','XML nao atende aos schemas fiscais.');end;
 end;
+procedure SchemaIntegral(M:TACBrNFe;const XML,Base,Name:string);
+var Err:string;
+begin
+ if not FileExists(Base+'schemas/'+Name)then Falhar('SCHEMAS_AUSENTES','Schema de recuperacao indisponivel.');
+ try
+  if not M.SSL.Validar(XML,Base+'schemas/'+Name,Err)then Falhar('XML_SCHEMA_INVALIDO','XML nao atende ao schema de recuperacao.');
+ except on E:EFiscal do raise;on E:Exception do Falhar('XML_SCHEMA_INVALIDO','XML nao atende ao schema de recuperacao.');end;
+end;
 procedure ProtocoloValido(const P:string);
 var I:Integer;
 begin
@@ -133,7 +157,7 @@ begin
  Estado(R,S);
 end;
 procedure Executar(Q,R:TJSONObject);
-var M:TACBrNFe;C,Inut:TJSONObject;Base,Cmd,XML,Key,Receipt,Err,J:string;Sending:Boolean;I,Found:Integer;
+var M:TACBrNFe;C,Inut:TJSONObject;Base,Cmd,XML,Key,Receipt,Err,J,Documento,Digest,ConsultaXML,ProtXML,Prot,Motivo:string;Sending:Boolean;I,Found,Code:Integer;
  procedure InicioEnvio;
  begin Sending:=True;R.Booleans['envioIniciado']:=True;MarcadorEnvio(Texto(Q,'id'));end;
 begin
@@ -153,6 +177,34 @@ begin
     Identidade(M,C);XML:=M.NotasFiscais.Items[0].GerarXML;
     if(XML='')or(Length(XML)>4*1024*1024)then Falhar('XML_INVALIDO','XML fiscal vazio ou acima do limite.');
     ChaveValida(M.NotasFiscais.Items[0].NumID,C,M);DefinirTexto(R,'chave',M.NotasFiscais.Items[0].NumID);DefinirTexto(R,'xmlBase64',EncodeStringBase64(XML));Estado(R,'XML_GERADO');
+   end else if Cmd='recuperarXml'then begin
+    CarregarXML(M,Q,C,XML);Key:=M.NotasFiscais.Items[0].NumID;
+    InspecionarAlvoRecuperacao(XML,Key,Documento,Digest);
+    SchemaIntegral(M,XML,Base,'nfe_v4.00.xsd');
+    if not M.SSL.VerificarAssinatura(XML,Err,'infNFe')then Falhar('ASSINATURA_INVALIDA','Assinatura fiscal invalida.');
+    { All input proof is complete and its raw source/digest are preserved above.
+      Clear the temporary model before the key-only query: the pinned ACBr
+      loaded-note path rewrites XMLOriginal with a literal-root writer and an
+      apostrophe replacement. Recovery independently proves the real RetWS. }
+    M.NotasFiscais.Clear;
+    M.WebServices.Consulta.NFeChave:=Key;M.WebServices.Consulta.ExtrairEventos:=False;
+    M.WebServices.Consulta.Executar;
+    ConsultaXML:=M.WebServices.Consulta.RetWS;
+    InspecionarConsultaRecuperacao(ConsultaXML,Key,Digest,Inteiro(C,'ambiente'),M.Configuracoes.WebServices.UFCodigo,Code,Motivo,Prot,ProtXML);
+    SchemaIntegral(M,ConsultaXML,Base,'retConsSitNFe_v4.00.xsd');
+    if Code<>100 then begin
+     R.Add('cStat',Code);DefinirTexto(R,'xMotivo',Motivo);DefinirTexto(R,'chave',Key);
+     DefinirTexto(R,'codigo','RECUPERACAO_NAO_COMPROVADA');Estado(R,'CONSULTADO');R.Booleans['sucesso']:=False;
+    end else begin
+     { Only the authentic query protocol and untouched original are used;
+       protocol scalars and a previous emission response are never composed. }
+     XML:=ComporRecuperacao(Documento,ProtXML);
+     ConferirRecuperacao(XML,Documento,ProtXML);
+     SchemaIntegral(M,XML,Base,'procNFe_v4.00.xsd');
+     if not M.SSL.VerificarAssinatura(XML,Err,'infNFe')then Falhar('ASSINATURA_INVALIDA','Assinatura fiscal invalida no XML recuperado.');
+     DefinirTexto(R,'chave',Key);DefinirTexto(R,'protocolo',Prot);R.Add('cStat',100);DefinirTexto(R,'xMotivo',Motivo);
+     DefinirTexto(R,'xmlBase64',EncodeStringBase64(XML));Estado(R,'XML_RECUPERADO');
+    end;
    end else if(Cmd='validar')or(Cmd='assinar')or(Cmd='transmitir')then begin
     CarregarXML(M,Q,C,XML);Key:=M.NotasFiscais.Items[0].NumID;DefinirTexto(R,'chave',Key);
     if Cmd='assinar'then begin

package/native/NativeProtocol.pas

@@ -47,7 +47,7 @@ begin
  OnlyKeys(O,'|versao|id|comando|sourceRevision|contractHash|config|documento|xmlBase64|chave|recibo|protocolo|justificativa|correcao|sequenciaEvento|inutilizacao|');
  if(Inteiro(O,'versao')<>1)or(Inteiro(O,'sourceRevision')<>SourceRevision)or(Texto(O,'contractHash')<>ContractHash)then Falhar('CONTRATO_INCOMPATIVEL','Contrato ou revisão ACBr incompatível.');
  S:=Texto(O,'id');if Length(S)>100 then Falhar('REQUISICAO_INVALIDA','Identificador inválido.');for I:=1 to Length(S)do if not(S[I]in['A'..'Z','a'..'z','0'..'9','_','-'])then Falhar('REQUISICAO_INVALIDA','Identificador inválido.');
- Cmd:=Texto(O,'comando');if Pos('|'+Cmd+'|','|gerarXml|validar|assinar|transmitir|consultar|cancelar|cartaCorrecao|inutilizar|')=0 then Falhar('REQUISICAO_INVALIDA','Comando fiscal inválido.');
+ Cmd:=Texto(O,'comando');if Pos('|'+Cmd+'|','|gerarXml|validar|assinar|transmitir|consultar|recuperarXml|cancelar|cartaCorrecao|inutilizar|')=0 then Falhar('REQUISICAO_INVALIDA','Comando fiscal inválido.');
  C:=Objeto(O,'config');OnlyKeys(C,'|cnpj|uf|modelo|ambiente|certificado|csc|');
  S:=Texto(C,'cnpj');if Length(S)<>14 then Falhar('REQUISICAO_INVALIDA','CNPJ inválido.');for I:=1 to Length(S)do if not(S[I]in['0'..'9'])then Falhar('REQUISICAO_INVALIDA','CNPJ inválido.');
  if not(Inteiro(C,'modelo')in[55,65])or not(Inteiro(C,'ambiente')in[1,2])then Falhar('REQUISICAO_INVALIDA','Modelo ou ambiente inválido.');
@@ -56,7 +56,8 @@ begin
  if C.Find('csc')<>nil then begin Cert:=Objeto(C,'csc');OnlyKeys(Cert,'|id|valor|');S:=Texto(Cert,'id');if Length(S)>6 then Falhar('REQUISICAO_INVALIDA','CSC inválido.');for I:=1 to Length(S)do if not(S[I]in['0'..'9'])then Falhar('REQUISICAO_INVALIDA','CSC inválido.');if Length(Texto(Cert,'valor'))>256 then Falhar('REQUISICAO_INVALIDA','CSC inválido.');end;
  if(Cmd='cartaCorrecao')and(Inteiro(C,'modelo')<>55)then Falhar('REQUISICAO_INVALIDA','Carta de correção restrita à NF-e.');
  if(Cmd='gerarXml')and(O.Find('documento')=nil)then Falhar('REQUISICAO_INVALIDA','Documento obrigatório para gerar XML.');
- if(Pos('|'+Cmd+'|','|validar|assinar|transmitir|')>0)and(O.Find('xmlBase64')=nil)then Falhar('REQUISICAO_INVALIDA','XML obrigatório.');
+ if(Pos('|'+Cmd+'|','|validar|assinar|transmitir|recuperarXml|')>0)and(O.Find('xmlBase64')=nil)then Falhar('REQUISICAO_INVALIDA','XML obrigatório.');
+ if(Cmd='recuperarXml')and((O.Find('chave')<>nil)or(O.Find('recibo')<>nil)or(O.Find('protocolo')<>nil)or(O.Find('documento')<>nil)or(O.Find('inutilizacao')<>nil)or(O.Find('justificativa')<>nil)or(O.Find('correcao')<>nil)or(O.Find('sequenciaEvento')<>nil))then Falhar('REQUISICAO_INVALIDA','Recuperacao recebe somente o XML original assinado.');
 end;
 procedure MarcadorEnvio(const Id:string);
 var O:TJSONObject;

package/native/NativeRecovery.pas

@@ -0,0 +1,274 @@
+unit NativeRecovery;
+{$mode objfpc}{$H+}{$codepage utf8}
+interface
+
+function ChaveAlvoRecuperacao(const XML:string):string;
+procedure InspecionarAlvoRecuperacao(const XML,Key:string;out Documento,Digest:string);
+procedure InspecionarConsultaRecuperacao(const XML,Key,Digest:string;
+ Ambiente,UFCodigo:Integer;out Code:Integer;out Motivo,Protocolo,XMLProtocolo:string);
+function ComporRecuperacao(const Documento,XMLProtocolo:string):string;
+procedure ConferirRecuperacao(const XML,Documento,XMLProtocolo:string);
+
+implementation
+uses Classes,SysUtils,DOM,XMLRead,NativeErrors;
+
+const NFeNS='http://www.portalfiscal.inf.br/nfe';
+ DSigNS='http://www.w3.org/2000/09/xmldsig#';
+ MaxXMLBytes=4*1024*1024;
+
+function Nome(N:TDOMNode):string;
+begin Result:=UTF8Encode(N.LocalName);if Result=''then Result:=UTF8Encode(N.NodeName);end;
+
+function Atributo(N:TDOMNode;const Name:string):string;
+var A:TDOMNode;
+begin Result:='';if N.Attributes=nil then Exit;A:=N.Attributes.GetNamedItem(UTF8Decode(Name));if A<>nil then Result:=UTF8Encode(A.NodeValue);end;
+
+procedure Invalido;
+begin Falhar('RETORNO_INVALIDO','XML fiscal de recuperacao invalido.');end;
+
+procedure Seguro(const XML:string);
+var U:string;
+begin
+ U:=UpperCase(XML);
+ if(XML='')or(Length(XML)>MaxXMLBytes)or(Pos(#0,XML)>0)or
+  (Pos('<!DOCTYPE',U)>0)or(Pos('<!ENTITY',U)>0)then Invalido;
+ if UTF8Encode(UTF8Decode(XML))<>XML then Invalido;
+end;
+
+function Ler(const XML:string):TXMLDocument;
+var S:TStringStream;Parser:TDOMParser;Source:TXMLInputSource;
+begin
+ Seguro(XML);Result:=nil;S:=TStringStream.Create(XML);Parser:=TDOMParser.Create;Source:=TXMLInputSource.Create(S);
+ try
+  Parser.Options.Namespaces:=True;Parser.Options.DisallowDoctype:=True;
+  Parser.Options.ExpandEntities:=False;Parser.Options.MaxChars:=MaxXMLBytes;
+  try Parser.Parse(Source,Result);except Result.Free;Result:=nil;Invalido;end;
+ finally Source.Free;Parser.Free;S.Free;end;
+ if(Result=nil)or(Result.DocumentElement=nil)then begin Result.Free;Invalido;end;
+end;
+
+procedure Raiz(D:TXMLDocument;const Name,Version:string);
+begin
+ if(Nome(D.DocumentElement)<>Name)or(UTF8Encode(D.DocumentElement.NamespaceURI)<>NFeNS)or
+  ((Version<>'')and(Atributo(D.DocumentElement,'versao')<>Version))then Invalido;
+end;
+
+function Filho(N:TDOMNode;const Name,NS:string;Required:Boolean=True):TDOMNode;
+var C:TDOMNode;
+begin
+ Result:=nil;C:=N.FirstChild;
+ while C<>nil do begin
+  if(C.NodeType=ELEMENT_NODE)and(Nome(C)=Name)then begin
+   if(Result<>nil)or(UTF8Encode(C.NamespaceURI)<>NS)then Invalido;Result:=C;
+  end;
+  C:=C.NextSibling;
+ end;
+ if Required and(Result=nil)then Invalido;
+end;
+
+function Valor(N:TDOMNode;const Name:string;Required:Boolean=True):string;
+var C,V:TDOMNode;
+begin
+ C:=Filho(N,Name,NFeNS,Required);Result:='';
+ if C<>nil then begin
+  V:=C.FirstChild;while V<>nil do begin if V.NodeType=ELEMENT_NODE then Invalido;V:=V.NextSibling;end;
+  Result:=UTF8Encode(C.TextContent);
+  if Required and(Result='')then Invalido;
+ end;
+end;
+
+procedure SemEnvelope(N:TDOMNode;Depth:Integer=0);
+var C:TDOMNode;S:string;
+begin
+ if Depth>128 then Invalido;
+ C:=N.FirstChild;
+ while C<>nil do begin
+  if C.NodeType=ELEMENT_NODE then begin
+   S:=Nome(C);
+   if(S='NFe')or(S='nfeProc')or(S='protNFe')or(S='enviNFe')then Invalido;
+   SemEnvelope(C,Depth+1);
+  end;
+  C:=C.NextSibling;
+ end;
+end;
+
+function Branco(C:Char):Boolean;
+begin Result:=C in[#9,#10,#13,' '];end;
+
+{ The DOM establishes well-formedness, cardinality and namespaces. This scanner
+  only locates byte ranges in that already parsed document; it never interprets
+  fiscal values or rewrites signed content. }
+function Fragmento(const XML,ChildName:string):string;
+var I,J,K,Depth,Start,Last,RootStart,RootEnd,Count:Integer;
+ Quote:Char;Tag,Local:string;Closing,Empty:Boolean;
+begin
+ I:=1;Depth:=0;Start:=0;Last:=0;RootStart:=0;RootEnd:=0;Count:=0;
+ while I<=Length(XML)do begin
+  if XML[I]<>'<'then begin Inc(I);Continue;end;
+  if Copy(XML,I,4)='<!--'then begin
+   J:=I+4;while(J<=Length(XML)-2)and(Copy(XML,J,3)<>'-->')do Inc(J);
+   I:=J+3;Continue;
+  end;
+  if Copy(XML,I,9)='<![CDATA['then begin
+   J:=I+9;while(J<=Length(XML)-2)and(Copy(XML,J,3)<>']]>')do Inc(J);
+   I:=J+3;Continue;
+  end;
+  if Copy(XML,I,2)='<?'then begin
+   J:=I+2;while(J<=Length(XML)-1)and(Copy(XML,J,2)<>'?>')do Inc(J);
+   I:=J+2;Continue;
+  end;
+  J:=I+1;Quote:=#0;
+  while J<=Length(XML)do begin
+   if Quote<>#0 then begin if XML[J]=Quote then Quote:=#0;end
+   else if XML[J]in['"',#39]then Quote:=XML[J]
+   else if XML[J]='>'then Break;
+   Inc(J);
+  end;
+  if J>Length(XML)then Invalido;
+  K:=I+1;Closing:=XML[K]='/';if Closing then Inc(K);
+  Tag:='';while(K<J)and not Branco(XML[K])and not(XML[K]in['/','>'])do begin Tag:=Tag+XML[K];Inc(K);end;
+  Local:=Copy(Tag,Pos(':',Tag)+1,MaxInt);K:=J-1;
+  while(K>I)and Branco(XML[K])do Dec(K);Empty:=XML[K]='/';
+  if Closing then begin
+   Dec(Depth);
+   if(ChildName<>'')and(Depth=1)and(Start>0)and(Last=0)then Last:=J;
+   if Depth=0 then RootEnd:=J;
+  end else begin
+   if Depth=0 then begin if RootStart<>0 then Invalido;RootStart:=I;end;
+   if(ChildName<>'')and(Depth=1)and(Local=ChildName)then begin
+    Inc(Count);if Count<>1 then Invalido;Start:=I;if Empty then Last:=J;
+   end;
+   if not Empty then Inc(Depth)else if Depth=0 then RootEnd:=J;
+  end;
+  I:=J+1;
+ end;
+ if ChildName=''then begin Start:=RootStart;Last:=RootEnd;end;
+ if(Start=0)or(Last<Start)then Invalido;
+ Result:=Copy(XML,Start,Last-Start+1);
+end;
+
+function Escapar(const S:string):string;
+begin
+ Result:=StringReplace(S,'&','&amp;',[rfReplaceAll]);
+ Result:=StringReplace(Result,'"','&quot;',[rfReplaceAll]);
+ Result:=StringReplace(Result,'<','&lt;',[rfReplaceAll]);
+end;
+
+function ProtocoloFechado(const XML:string;Root,Prot:TDOMNode):string;
+var I,P:Integer;A:TDOMNode;Name,Extra:string;
+begin
+ Result:=Fragmento(XML,'protNFe');Extra:='';
+ { A direct child can inherit namespace bindings from retConsSitNFe. Copy only
+   those declarations, onto that protocol alone, so the NFe signature context
+   cannot acquire new prefix bindings from the consultation. }
+ for I:=0 to Root.Attributes.Length-1 do begin
+  A:=Root.Attributes.Item[I];Name:=UTF8Encode(A.NodeName);
+  if((Name='xmlns')or(Copy(Name,1,6)='xmlns:'))and(Atributo(Prot,Name)='')then
+   Extra:=Extra+' '+Name+'="'+Escapar(UTF8Encode(A.NodeValue))+'"';
+ end;
+ if Extra<>''then begin
+  P:=2;while(P<=Length(Result))and not Branco(Result[P])and not(Result[P]in['/','>'])do Inc(P);
+  Insert(Extra,Result,P);
+ end;
+end;
+
+function ChaveAlvoRecuperacao(const XML:string):string;
+var D:TXMLDocument;Info:TDOMNode;Id:string;
+begin
+ D:=Ler(XML);
+ try
+  Raiz(D,'NFe','');SemEnvelope(D.DocumentElement);
+  Info:=Filho(D.DocumentElement,'infNFe',NFeNS);Id:=Atributo(Info,'Id');
+  if(Length(Id)<>47)or(Copy(Id,1,3)<>'NFe')then Invalido;
+  Result:=Copy(Id,4,44);
+ finally D.Free;end;
+end;
+
+procedure InspecionarAlvoRecuperacao(const XML,Key:string;out Documento,Digest:string);
+var D:TXMLDocument;R,Info,Sig,SignedInfo,Ref,DigestNode,C:TDOMNode;
+begin
+ D:=Ler(XML);
+ try
+  Raiz(D,'NFe','');R:=D.DocumentElement;SemEnvelope(R);
+  Info:=Filho(R,'infNFe',NFeNS);if(Atributo(Info,'Id')<>'NFe'+Key)or(Atributo(Info,'versao')<>'4.00')then Invalido;
+  Sig:=Filho(R,'Signature',DSigNS,False);
+  if Sig=nil then Falhar('XML_NAO_ASSINADO','Recuperacao exige a NFe original assinada.');
+  C:=R.FirstChild;while C<>nil do begin
+   if(C.NodeType=ELEMENT_NODE)and(C<>Info)and(C<>Sig)and(C<>Filho(R,'infNFeSupl',NFeNS,False))then Invalido;
+   C:=C.NextSibling;
+  end;
+  SignedInfo:=Filho(Sig,'SignedInfo',DSigNS);Ref:=Filho(SignedInfo,'Reference',DSigNS);
+  if Atributo(Ref,'URI')<>'#NFe'+Key then Falhar('ASSINATURA_INVALIDA','Assinatura nao referencia a NFe original.');
+  DigestNode:=Filho(Ref,'DigestValue',DSigNS);Digest:=UTF8Encode(DigestNode.TextContent);
+  if Digest=''then Falhar('ASSINATURA_INVALIDA','Assinatura fiscal sem digest.');
+  Documento:=Fragmento(XML,'');
+ finally D.Free;end;
+end;
+
+procedure InspecionarConsultaRecuperacao(const XML,Key,Digest:string;
+ Ambiente,UFCodigo:Integer;out Code:Integer;out Motivo,Protocolo,XMLProtocolo:string);
+var D:TXMLDocument;R,Prot,Info:TDOMNode;ReturnedDigest:string;I:Integer;
+begin
+ Protocolo:='';XMLProtocolo:='';D:=Ler(XML);
+ try
+  Raiz(D,'retConsSitNFe','4.00');R:=D.DocumentElement;
+  if(Valor(R,'chNFe')<>Key)or(Valor(R,'tpAmb')<>IntToStr(Ambiente))or(Valor(R,'cUF')<>IntToStr(UFCodigo))then
+   Falhar('IDENTIDADE_DIVERGENTE','Consulta retornou outro documento ou ambiente.');
+  Code:=StrToIntDef(Valor(R,'cStat'),0);Motivo:=Valor(R,'xMotivo');
+  Prot:=Filho(R,'protNFe',NFeNS,False);
+  if Code<>100 then Exit;
+  if(Filho(R,'retCancNFe',NFeNS,False)<>nil)or(Filho(R,'procEventoNFe',NFeNS,False)<>nil)then
+   Falhar('RECUPERACAO_NAO_COMPROVADA','Consulta contem evento que exige analise separada.');
+  if Prot=nil then Falhar('RECUPERACAO_NAO_COMPROVADA','Consulta autorizada sem protocolo completo.');
+  if Atributo(Prot,'versao')<>'4.00'then Invalido;
+  { The pinned signature verifier resolves SignedInfo globally. It cannot
+    establish both signatures independently in a two-signature process. Do not
+    return a process whose optional protocol signature has not been proved. }
+  if Filho(Prot,'Signature',DSigNS,False)<>nil then
+   Falhar('RECUPERACAO_NAO_COMPROVADA','Protocolo com assinatura adicional exige verificacao independente.');
+  Info:=Filho(Prot,'infProt',NFeNS);
+  if(Valor(Info,'chNFe')<>Key)or(Valor(Info,'tpAmb')<>IntToStr(Ambiente))or(Valor(Info,'cStat')<>'100')then
+   Falhar('IDENTIDADE_DIVERGENTE','Protocolo retornou outro documento, ambiente ou situacao.');
+  Protocolo:=Valor(Info,'nProt',False);
+  if Length(Protocolo)<>15 then Falhar('RECUPERACAO_NAO_COMPROVADA','Consulta autorizada sem protocolo completo.');
+  for I:=1 to Length(Protocolo)do if not(Protocolo[I]in['0'..'9'])then Invalido;
+  ReturnedDigest:=Valor(Info,'digVal',False);
+  if(ReturnedDigest='')or(Digest='')then Falhar('RECUPERACAO_NAO_COMPROVADA','Consulta sem digest para comprovar a NFe original.');
+  if ReturnedDigest<>Digest then Falhar('IDENTIDADE_DIVERGENTE','Digest da consulta diverge da NFe original assinada.');
+  XMLProtocolo:=ProtocoloFechado(XML,R,Prot);
+ finally D.Free;end;
+end;
+
+function ComporRecuperacao(const Documento,XMLProtocolo:string):string;
+var D:TXMLDocument;QName,Prefix,ProcessName,Declaration:string;P:Integer;
+begin
+ { Only a fixed process envelope is written here. Neither the signed NFe nor
+   fiscal protocol fields are generated from scalar values. Reuse the NFe's
+   namespace prefix: introducing a different binding on an ancestor can change
+   inclusive canonicalization even while all signed source bytes stay equal. }
+ D:=Ler(Documento);
+ try
+  Raiz(D,'NFe','');QName:=UTF8Encode(D.DocumentElement.NodeName);P:=Pos(':',QName);
+  Prefix:='';if P>0 then Prefix:=Copy(QName,1,P-1);
+  ProcessName:='nfeProc';Declaration:='xmlns';
+  if Prefix<>''then begin ProcessName:=Prefix+':nfeProc';Declaration:=Declaration+':'+Prefix;end;
+  Result:='<?xml version="1.0" encoding="UTF-8"?><'+ProcessName+' '+Declaration+'="'+NFeNS+'" versao="4.00">'+Documento+XMLProtocolo+'</'+ProcessName+'>';
+ finally D.Free;end;
+ if Length(Result)>MaxXMLBytes then Invalido;
+end;
+
+procedure ConferirRecuperacao(const XML,Documento,XMLProtocolo:string);
+var D:TXMLDocument;R,C,N,P:TDOMNode;
+begin
+ D:=Ler(XML);
+ try
+  Raiz(D,'nfeProc','4.00');R:=D.DocumentElement;
+  N:=Filho(R,'NFe',NFeNS);P:=Filho(R,'protNFe',NFeNS);
+  C:=R.FirstChild;while C<>nil do begin
+   if(C.NodeType=ELEMENT_NODE)and(C<>N)and(C<>P)then Invalido;C:=C.NextSibling;
+  end;
+  if(Fragmento(XML,'NFe')<>Documento)or(Fragmento(XML,'protNFe')<>XMLProtocolo)then
+   Falhar('XML_ALTERADO','Recuperacao alterou o documento ou protocolo original.');
+ finally D.Free;end;
+end;
+end.