private void AmpliarFirma(SignatureFormat formato)
{
try
{
UpgradeParameters parametros = new UpgradeParameters();
parametros.TimeStampClient = new TimeStampClient(txtURLSellado.Text);
parametros.OCSPServers.Add(new OcspServer(txtOCSP.Text));
// test con @firma
/* parametros.GetOcspUrlFromCertificate = false;
* OcspServer ocspServer = new OcspServer("https://afirma.redsara.es/servidorOcsp/servidorOCSP");
* ocspServer.SetRequestorName(OcspServer.Rfc822Name, "idAplicacion");
* ocspServer.SignCertificate = CertUtil.SelectCertificate();
*
* parametros.OCSPServers.Add(ocspServer); */
XadesUpgraderService upgrader = new XadesUpgraderService();
upgrader.Upgrade(_signatureDocument, formato, parametros);
MessageBox.Show("Firma ampliada correctamente", "Test firma XADES",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show("Ha ocurrido un error ampliando la firma: " + ex.Message);
}
}
private static bool NextArgType(Tokenizer tokenizer, SignatureFormat signatureFormat, TokenType endBracket, out string argType)
{
var next = tokenizer.Peek();
argType = null;
if (next.HasValue && next.Value.Kind == endBracket)
{
return(false);
}
tokenizer.Eat(TokenType.WhiteSpace);
argType = ParseType(tokenizer, signatureFormat);
int lastDot = Math.Max(argType.LastIndexOf('.'), argType.LastIndexOf('/'));
if (lastDot > 0)
{
argType = argType.Substring(lastDot + 1);
}
if (signatureFormat.Has(SignatureFormat.ParameterNames))
{
tokenizer.Expect(TokenType.WhiteSpace);
tokenizer.Expect(TokenType.Identifier);
}
return(true);
}
private static Signature ParseSignature(string input, SignatureFormat signatureFormat, string methodName = null)
{
Tokenizer tokenizer = new Tokenizer(input);
tokenizer.Eat(TokenType.WhiteSpace);
if (signatureFormat.Has(SignatureFormat.AtPrefix))
{
tokenizer.Expect(TokenType.Identifier); // "at" or "à" or similar, depending on language
tokenizer.Expect(TokenType.WhiteSpace);
}
if (signatureFormat.Has(SignatureFormat.ReturnType))
{
ParseType(tokenizer, signatureFormat); // Ignore return type.
}
if (signatureFormat.Has(SignatureFormat.MethodName))
{
if (methodName != null)
{
throw new ArgumentException("Don't pass method name");
}
methodName = ParseQualifiedMethodName(tokenizer, signatureFormat);
}
tokenizer.Expect(TokenType.LeftParen);
var args = ParseArgumentList(tokenizer, TokenType.RightParen, signatureFormat);
tokenizer.Expect(TokenType.RightParen);
return(new Signature(methodName, args));
}
public static SignatureByte SignMessage(this PrivateKey key, byte[] hash, Network network)
{
// TODO add a prefix to prevent cross protocol signature
var data = SignatureEngine.FormatMessageForSigning(hash, network);
// TODO NBitcoin.Key.SignCompact
var signature = key.Sign(data);
Debug.Assert(key.Verify(data, signature));
return(SignatureFormat.ToBytes(signature));
}
/// <summary>
/// Método para la verificación de firmas
/// </summary>
/// <param name="signature"></param>
/// <param name="signatureFormat"></param>
public void VerifySignature(byte[] signature, SignatureFormat signatureFormat)
{
object signatureObject = GetSignatureObject(signature, signatureFormat);
VerifyResponse response = SendRequest(signatureObject);
if (response.Result.ResultMajor != "urn:afirma:dss:1.0:profile:XSS:resultmajor:ValidSignature")
{
throw new Exception(response.Result.ResultMessage.Value);
}
}
private SignatureExtension GetExtensionProfile(SignatureParameters parameters)
{
//jbonilla
SignatureFormat signFormat = parameters.SignatureFormat;
if (signFormat.Equals(SignatureFormat.XAdES_BES) || signFormat.Equals(SignatureFormat
.XAdES_EPES))
{
return(null);
}
else if (signFormat.Equals(SignatureFormat.XAdES_T))
{
XAdESProfileT extensionT = new XAdESProfileT();
extensionT.SetTspSource(TspSource);
return(extensionT);
}
else if (signFormat.Equals(SignatureFormat.XAdES_C))
{
XAdESProfileC extensionC = new XAdESProfileC();
extensionC.SetTspSource(TspSource);
extensionC.SetCertificateVerifier(Verifier);
return(extensionC);
}
else if (signFormat.Equals(SignatureFormat.XAdES_X))
{
XAdESProfileX extensionX = new XAdESProfileX();
extensionX.SetTspSource(TspSource);
extensionX.SetCertificateVerifier(Verifier);
return(extensionX);
}
else if (signFormat.Equals(SignatureFormat.XAdES_XL))
{
XAdESProfileXL extensionXL = new XAdESProfileXL();
extensionXL.SetTspSource(TspSource);
extensionXL.SetCertificateVerifier(Verifier);
return(extensionXL);
}
// else
// {
// if (signFormat.Equals(SignatureFormat.XAdES_A))
// {
// throw new NotImplementedException();
// //XAdESProfileA extensionA = new XAdESProfileA();
// //extensionA.SetTspSource(tspSource);
// //extensionA.SetCertificateVerifier(certificateVerifier);
// //return extensionA;
// }
// }
// }
// }
// }
//}
throw new ArgumentException("Unsupported signature format " + parameters.SignatureFormat);
}
/// <summary>
/// Método para realizar la ampliación de firmas
/// </summary>
/// <param name="signature"></param>
/// <param name="signatureFormat"></param>
/// <param name="returnUpdatedSignatureType"></param>
/// <returns></returns>
public byte[] UpgradeSignature(byte[] signature, SignatureFormat signatureFormat, string returnUpdatedSignatureType)
{
object signatureObject = GetSignatureObject(signature, signatureFormat);
VerifyResponse response = SendRequest(signatureObject, returnUpdatedSignatureType);
if (response.Result.ResultMajor == "urn:oasis:names:tc:dss:1.0:resultmajor:Success")
{
XmlElement updatedSignatureXmlElement = response.OptionalOutputs.Any.Single(e => e.LocalName == "UpdatedSignature");
UpdatedSignatureType updatedSignatureType = DeserializeXml <UpdatedSignatureType>(updatedSignatureXmlElement.OuterXml);
if (updatedSignatureType.SignatureObject.Item.GetType() == typeof(SignaturePtr))
{
SignaturePtr signaturePtr = updatedSignatureType.SignatureObject.Item as SignaturePtr;
DocumentWithSignature docWithSignature = null;
IEnumerable <XmlElement> documentWithSignatureXmlElements = response.OptionalOutputs.Any.Where(e => e.LocalName == "DocumentWithSignature");
foreach (var item in documentWithSignatureXmlElements)
{
docWithSignature = DeserializeXml <DocumentWithSignature>(item.OuterXml);
if (docWithSignature.Document.ID == signaturePtr.WhichDocument)
{
break;
}
}
if (docWithSignature == null)
{
throw new Exception("No se ha encontrado el documento de firma");
}
else
{
return(docWithSignature.Document.Item as byte[]);
}
}
else if (updatedSignatureType.SignatureObject.Item.GetType() == typeof(Base64Signature))
{
Base64Signature b64Signature = updatedSignatureType.SignatureObject.Item as Base64Signature;
return(b64Signature.Value);
}
else
{
throw new Exception("Tipo de resultado no soportado");
}
}
else
{
throw new Exception(response.Result.ResultMessage.Value);
}
}
private CAdESSignatureExtension GetExtensionProfile(SignatureParameters parameters
)
{
//jbonilla
SignatureFormat signFormat = parameters.SignatureFormat;
if (signFormat.Equals(SignatureFormat.CAdES_BES) || signFormat.Equals(SignatureFormat
.CAdES_EPES))
{
return(null);
}
else if (signFormat.Equals(SignatureFormat.CAdES_T))
{
CAdESProfileT extensionT = new CAdESProfileT();
extensionT.SetSignatureTsa(TspSource);
return(extensionT);
}
else if (signFormat.Equals(SignatureFormat.CAdES_C))
{
CAdESProfileC extensionC = new CAdESProfileC();
extensionC.SetSignatureTsa(TspSource);
extensionC.SetCertificateVerifier(Verifier);
return(extensionC);
}
else if (signFormat.Equals(SignatureFormat.CAdES_X))
{
CAdESProfileX extensionX = new CAdESProfileX();
extensionX.SetSignatureTsa(TspSource);
extensionX.SetExtendedValidationType(1);
extensionX.SetCertificateVerifier(Verifier);
return(extensionX);
}
else if (signFormat.Equals(SignatureFormat.CAdES_XL))
{
CAdESProfileXL extensionXL = new CAdESProfileXL();
extensionXL.SetSignatureTsa(TspSource);
extensionXL.SetExtendedValidationType(1);
extensionXL.SetCertificateVerifier(Verifier);
return(extensionXL);
}
else if (signFormat.Equals(SignatureFormat.CAdES_A))
{
CAdESProfileA extensionA = new CAdESProfileA();
extensionA.SetSignatureTsa(TspSource);
extensionA.SetCertificateVerifier(Verifier);
extensionA.SetExtendedValidationType(1);
return(extensionA);
}
throw new ArgumentException("Unsupported signature format " + parameters.SignatureFormat);
}
public HydraSignatureEnhanced(byte[] signatureData)
{
Contract.Assert(signatureData != null);
this.signatureType = SignatureFormat.Unknown;
this.id = InvalidId; // Start with an invalid ID
if ((signatureData != null) && (signatureData.Length >= 1))
{ // Must have at least 1 byte to be a valid signature
byte[] reverseSignatureData = new byte[signatureData.Length];
for (int i = 0; i < signatureData.Length; i++)
{ // Reverse all bits to match "endian"
reverseSignatureData[i] = ReverseByte(signatureData[i]);
}
this.data = new BitArray(reverseSignatureData);
this.bitOffset = 0;
if (this.data[0] == true)
{ // Legacy signature always with "Move" instruction (e.g., first bit is 1)
this.signatureType = SignatureFormat.Legacy;
this.startBitOffset = 0; // Start with bit(0) - "Move"
}
else if ((reverseSignatureData[0] == 0) && (signatureData.Length >= SignatureHeaderLength))
{ // Enhanced format signature (first 8 bits must alwasy be 0)
this.signatureType = SignatureFormat.Enhanced;
// Signature Header:
// 8: ID (all bits 0)
// 8: HeaderDataLengths (MSB first, = 8)
// 16: X-Axis scaled resolution (hor full-scale range up to 2048, MSB first)
// 16: Y-Axis scaled resolution (vert full-scale range up to 1024, MSB fist)
// 16: X-Axis physical size (withd of pad in 0.01 mm units, for the ICE5500 this is 6717 which corresponding to 67.17mm, MSB first)
// 16: Y-Axis phy size (hight of pad in 0.01 mm units, MSB first)
this.id = this.ReadByte(8); // Enhanced Signature first 8 bits should alwasy be zero(0)
this.headerLength = this.ReadByte(8);
this.startBitOffset = (2 /* this.id + len */ + this.headerLength) * 8 /* 8 bits in byte */;
this.axisScaleX = this.ReadInt(16, false);
this.axisScaleY = this.ReadInt(16, false);
this.phySizeX = this.ReadInt(16, false);
this.phySizeY = this.ReadInt(16, false);
}
}
else
{
NetTracer.Warning("L5300Terminal - L5300SignatureEnhanced - null or invalid signature header");
}
}
private object GetSignatureObject(byte[] signature, SignatureFormat signatureFormat)
{
if (signatureFormat == SignatureFormat.PAdES)
{
Base64Data b64Data = new Base64Data();
b64Data.MimeType = "application/pdf";
b64Data.Value = signature;
return(b64Data);
}
else
{
return(signature);
}
}
/// <summary>Because some information are stored in the profile, a profile is not Thread-safe.
/// </summary>
/// <remarks>
/// Because some information are stored in the profile, a profile is not Thread-safe. The software must create one
/// for each request.
/// </remarks>
/// <returns>A new instance of signatureProfile corresponding to the parameters.</returns>
private CAdESProfileBES GetSigningProfile(SignatureParameters parameters)
{
//jbonilla
SignatureFormat signFormat = parameters.SignatureFormat;
if (signFormat.Equals(SignatureFormat.CAdES_BES))
{
return(new CAdESProfileBES());
}
else
{
if (signFormat.Equals(SignatureFormat.CAdES_EPES))
{
return(new CAdESProfileEPES());
}
}
return(new CAdESProfileEPES());
}
private XAdESProfileBES GetSigningProfile(SignatureParameters parameters)
{
//jbonilla
SignatureFormat signFormat = parameters.SignatureFormat;
if (signFormat.Equals(SignatureFormat.XAdES_BES))
{
return(new XAdESProfileBES());
}
//else
//{
// if (signFormat.Equals(SignatureFormat.XAdES_EPES))
// {
// return new XAdESProfileEPES();
// }
//}
//TODO jbonilla EPES?
return(new XAdESProfileBES());
}
private void AmpliarFirma(SignatureFormat formato)
{
try
{
UpgradeParameters parametros = new UpgradeParameters();
parametros.TimeStampClient = new TimeStampClient(txtURLSellado.Text);
parametros.OCSPServers.Add(txtOCSP.Text);
XadesUpgraderService upgrader = new XadesUpgraderService();
upgrader.Upgrade(_signatureDocument, formato, parametros);
MessageBox.Show("Firma ampliada correctamente", "Test firma XADES",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show("Ha ocurrido un error ampliando la firma: " + ex.Message);
}
}
private void AmpliarFirma(SignatureFormat formato)
{
try
{
UpgradeParameters parametros = new UpgradeParameters
{
TimeStampClient = new TimeStampClient(txtURLSellado.Text)
};
parametros.OCSPServers.Add(new OcspServer(txtOCSP.Text));
XadesUpgraderService upgrader = new XadesUpgraderService();
upgrader.Upgrade(_signatureDocument, formato, parametros);
MessageBox.Show("Signature extended correctly", $"Extend to {formato.ToString()}",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show("An error has occurred extending the signature: " + ex.Message);
}
}
private static string ParseQualifiedMethodName(Tokenizer tokenizer, SignatureFormat signatureFormat)
{
StringBuilder result = new StringBuilder();
Token? next;
do
{
next = tokenizer.Peek();
if (!next.HasValue)
{
tokenizer.Fail("Expected qualified method name, found EOF");
}
if (next.Value.Kind != TokenType.LeftParen)
{
tokenizer.Next();
result.Append(next.Value.ToString(tokenizer.Input));
}
} while (next.Value.Kind != TokenType.LeftParen);
return(result.ToString());
}
public void Upgrade(SignatureDocument sigDocument, SignatureFormat toFormat, UpgradeParameters parameters)
{
XadesTUpgrader xadesTUpgrader = null;
XadesXLUpgrader xadesXLUpgrader = null;
SignatureDocument.CheckSignatureDocument(sigDocument);
if (toFormat == SignatureFormat.XAdES_T)
{
xadesTUpgrader = new XadesTUpgrader();
xadesTUpgrader.Upgrade(sigDocument, parameters);
}
else
{
if (sigDocument.XadesSignature.UnsignedProperties.UnsignedSignatureProperties.SignatureTimeStampCollection.Count == 0)
{
xadesTUpgrader = new XadesTUpgrader();
xadesTUpgrader.Upgrade(sigDocument, parameters);
}
xadesXLUpgrader = new XadesXLUpgrader();
xadesXLUpgrader.Upgrade(sigDocument, parameters);
}
}
private object GetDocument(byte[] signature, SignatureFormat signatureFormat)
{
if (signatureFormat == SignatureFormat.XAdES)
{
return(signature);
}
Base64Data b64Data = new Base64Data();
if (signatureFormat == SignatureFormat.PAdES)
{
b64Data.MimeType = "application/pdf";
}
else
{
b64Data.MimeType = "application/octet-stream";
}
b64Data.Value = signature;
return(b64Data);
}
/// <summary>
/// Sets the signature format based on the item selected from the dropdown.
/// </summary>
/// <param name="formatInput">
/// The signature format.
/// </param>
public void SetFormat(string formatInput)
{
this.format = formatInput;
switch (this.format)
{
case "Ascii3Byte":
this.signatureFormat = SignatureFormat.Ascii3Byte;
break;
case "PointsBigEndian":
this.signatureFormat = SignatureFormat.PointsBigEndian;
break;
case "PointsLittleEndian":
this.signatureFormat = SignatureFormat.PointsLittleEndian;
break;
default:
this.signaturePoints = null;
break;
}
}
string SignDocument(X509Certificate2 signCertificate, System.IO.Stream inputStream, SignatureProductionPlace signatureProductionPlace, string timeStampUrl = "https://freetsa.org/tsr", SignatureFormat format = SignatureFormat.XAdES_T)
{
FirmaXadesNet.XadesService svc = new FirmaXadesNet.XadesService();
var parameters = new SignatureParameters()
{
SignatureMethod = SignatureMethod.RSAwithSHA256,
SigningDate = DateTime.Now,
SignaturePackaging = SignaturePackaging.ENVELOPED,
InputMimeType = "text/xml",
SignatureProductionPlace = signatureProductionPlace
};
parameters.SignatureCommitments.Add(new SignatureCommitment(SignatureCommitmentType.ProofOfOrigin));
using (parameters.Signer = new Signer(signCertificate))
{
var signedDocument = svc.Sign(inputStream, parameters);
signedDocument.Document.PreserveWhitespace = true;
UpgradeParameters xadesTparameters = new UpgradeParameters()
{
TimeStampClient = new TimeStampClient(timeStampUrl)
};
if (format == SignatureFormat.XAdES_XL)
{
xadesTparameters.OCSPServers.Add(new OcspServer("http://srvdc06.crossroad.ltd/ocsp"));
}
XadesUpgraderService upgrader = new XadesUpgraderService();
upgrader.Upgrade(signedDocument, format, xadesTparameters);
return(signedDocument.Document.OuterXml);
}
}
public static bool Has(this SignatureFormat f, SignatureFormat flag)
{
return((f & flag) == flag);
}
private static string ParseType(Tokenizer tokenizer, SignatureFormat signatureFormat, bool allowArray = true)
{
var t = tokenizer.Expect(TokenType.Identifier);
string typeName = t.ToString(tokenizer.Input);//.Replace("/", ".").Replace("+", ".");
if (typeName == "native")
{
throw new NotSupportedException("Native int");
}
if (typeName == "unsigned")
{
tokenizer.Expect(TokenType.WhiteSpace);
typeName = tokenizer.Expect(TokenType.Identifier).ToString(tokenizer.Input);
typeName = ResolveUnsignedPrimitive(typeName);
}
else
{
typeName = ResolvePrimitive(typeName);
}
var arrayOrGenericInfo = tokenizer.Peek();
if (arrayOrGenericInfo.HasValue && signatureFormat.Has(SignatureFormat.GenericArity) && arrayOrGenericInfo.Value.Kind == TokenType.BackTick)
{
tokenizer.Next();
string arity = tokenizer.Expect(TokenType.Number).ToString(tokenizer.Input);
typeName = string.Format("{0}`{1}", typeName, arity);
arrayOrGenericInfo = tokenizer.Peek();
}
if (arrayOrGenericInfo.HasValue && signatureFormat.Has(SignatureFormat.GenericTypes) && arrayOrGenericInfo.Value.Kind == TokenType.LeftAngleBracket)
{
tokenizer.Next();
// Comma separated list of types.
var genericArgs = ParseArgumentList(tokenizer, TokenType.RightAngleBracket, signatureFormat);
tokenizer.Expect(TokenType.RightAngleBracket);
if (!signatureFormat.Has(SignatureFormat.GenericArity))
{
typeName = string.Format("{0}`{1}", typeName, genericArgs.Count);
}
}
if (arrayOrGenericInfo.HasValue && arrayOrGenericInfo.Value.Kind == TokenType.Slash)
{
// Nested type
tokenizer.Next();
string nestedType = ParseType(tokenizer, signatureFormat);
typeName = string.Format("{0}+{1}", typeName, nestedType);
}
if (allowArray)
{
typeName = typeName + ParseArraySuffix(tokenizer);
}
if (tokenizer.Eat(TokenType.Ampersand))
{
typeName += "&";
}
return(typeName);
}
/// <summary> /// 修改用户资料 /// </summary> public abstract bool UpdateUserProfile(int usrID, Gender gender, Int16 birthYear, Int16 birthMonth, Int16 birthday, string signature, SignatureFormat signatureFormat, float timeZone, UserExtendedValueCollection extendedFields);
public static byte[] Sign(byte[] message, byte[] prikey, byte[] pubkey, Phantasma.Cryptography.ECC.ECDsaCurve phaCurve = Phantasma.Cryptography.ECC.ECDsaCurve.Secp256r1, SignatureFormat signatureFormat = SignatureFormat.Concatenated)
{
var signer = SignerUtilities.GetSigner("SHA256withECDSA");
Org.BouncyCastle.Asn1.X9.X9ECParameters curve;
switch (phaCurve)
{
case Phantasma.Cryptography.ECC.ECDsaCurve.Secp256k1:
curve = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256k1");
break;
default:
curve = NistNamedCurves.GetByName("P-256");
break;
}
var dom = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H);
ECKeyParameters privateKeyParameters = new ECPrivateKeyParameters(new BigInteger(1, prikey), dom);
signer.Init(true, privateKeyParameters);
signer.BlockUpdate(message, 0, message.Length);
var sig = signer.GenerateSignature();
switch (signatureFormat)
{
case SignatureFormat.Concatenated:
// We convert from default DER format that Bouncy Castle uses to concatenated "raw" R + S format.
return(TranscodeSignatureToConcat(sig, 64));
case SignatureFormat.DEREncoded:
// Return DER-encoded signature unchanged.
return(sig);
default:
throw new Exception("Unknown signature format");
}
}
public static bool Verify(byte[] message, byte[] signature, byte[] pubkey, Phantasma.Cryptography.ECC.ECDsaCurve phaCurve = Phantasma.Cryptography.ECC.ECDsaCurve.Secp256r1, SignatureFormat signatureFormat = SignatureFormat.Concatenated)
{
var signer = SignerUtilities.GetSigner("SHA256withECDSA");
Org.BouncyCastle.Asn1.X9.X9ECParameters curve;
switch (phaCurve)
{
case Phantasma.Cryptography.ECC.ECDsaCurve.Secp256k1:
curve = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256k1");
break;
default:
curve = NistNamedCurves.GetByName("P-256");
break;
}
var dom = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H);
var point = dom.Curve.DecodePoint(pubkey);
var publicKeyParameters = new ECPublicKeyParameters(point, dom);
signer.Init(false, publicKeyParameters);
signer.BlockUpdate(message, 0, message.Length);
switch (signatureFormat)
{
case SignatureFormat.Concatenated:
// We convert from concatenated "raw" R + S format to DER format that Bouncy Castle uses.
signature = new Org.BouncyCastle.Asn1.DerSequence(
// first 32 bytes is "r" number
new Org.BouncyCastle.Asn1.DerInteger(new BigInteger(1, signature.Take(32).ToArray())),
// last 32 bytes is "s" number
new Org.BouncyCastle.Asn1.DerInteger(new BigInteger(1, signature.Skip(32).ToArray())))
.GetDerEncoded();
break;
case SignatureFormat.DEREncoded:
// Do nothing, signature already DER-encoded.
break;
default:
throw new Exception("Unknown signature format");
}
return(signer.VerifySignature(signature));
}
public byte[] UpgradeSignature(byte[] signature, SignatureFormat signatureFormat, ReturnUpdatedSignatureType returnUpdateSignatureType,
byte[] targetSignerCert = null, IEnumerable <DocumentBaseType> otherInputDocuments = null)
{
if (signature == null)
{
throw new ArgumentNullException("signature", "El valor no puede ser nulo.");
}
if (returnUpdateSignatureType == null)
{
throw new ArgumentNullException("returnUpdateSignatureType", "El valor no puede ser nulo.");
}
object document = GetDocument(signature, signatureFormat);
ReturnUpdatedSignature returnUpdated = new ReturnUpdatedSignature();
returnUpdated.Type = returnUpdateSignatureType.ResourceName;
IgnoreGracePeriod igp = new IgnoreGracePeriod();
DocumentType doc = new DocumentType();
doc.ID = "ID_DOCUMENTO";
doc.Item = document;
SignatureObject signatureObject = new SignatureObject();
signatureObject.Item = new SignaturePtr()
{
WhichDocument = "ID_DOCUMENTO"
};
List <DocumentBaseType> documents = new List <DocumentBaseType>();
documents.Add(doc);
if (otherInputDocuments != null)
{
foreach (var inputDocument in otherInputDocuments)
{
documents.Add(inputDocument);
}
}
List <XmlElement> optionalInputs = new List <XmlElement>();
optionalInputs.Add(GetXmlElement(igp));
optionalInputs.Add(GetXmlElement(returnUpdated));
if (targetSignerCert != null)
{
TargetSigner targetSigner = new TargetSigner();
targetSigner.Value = targetSignerCert;
optionalInputs.Add(GetXmlElement(targetSigner));
}
VerifyRequest request = BuildRequest(documents, signatureObject, optionalInputs);
DSSAfirmaVerifyService ds = new DSSAfirmaVerifyService(_identity, _serverCert);
string result = ds.verify(GetXmlElement(request).OuterXml);
VerifyResponse response = DeserializeXml <VerifyResponse>(result);
if (ResultType.Success.Equals(response.Result.ResultMajor))
{
XmlElement updatedSignatureXmlElement = response.OptionalOutputs.Any.Single(e => e.LocalName == "UpdatedSignature");
UpdatedSignatureType updatedSignatureType = DeserializeXml <UpdatedSignatureType>(updatedSignatureXmlElement.OuterXml);
if (updatedSignatureType.SignatureObject.Item.GetType() == typeof(SignaturePtr))
{
SignaturePtr signaturePtr = updatedSignatureType.SignatureObject.Item as SignaturePtr;
DocumentWithSignature docWithSignature = null;
IEnumerable <XmlElement> documentWithSignatureXmlElements = response.OptionalOutputs.Any.Where(e => e.LocalName == "DocumentWithSignature");
foreach (var item in documentWithSignatureXmlElements)
{
docWithSignature = DeserializeXml <DocumentWithSignature>(item.OuterXml);
if (docWithSignature.Document.ID == signaturePtr.WhichDocument)
{
return(docWithSignature.Document.Item as byte[]);
}
}
throw new Exception("No se ha encontrado el documento de firma");
}
else if (updatedSignatureType.SignatureObject.Item.GetType() == typeof(Base64Signature))
{
Base64Signature b64Signature = updatedSignatureType.SignatureObject.Item as Base64Signature;
return(b64Signature.Value);
}
else
{
throw new Exception("Tipo de resultado no soportado");
}
}
else
{
throw new AfirmaResultException(response.Result.ResultMajor, response.Result.ResultMinor, response.Result.ResultMessage.Value);
}
}
public VerifyResponse VerifySignature(byte[] signature, SignatureFormat signatureFormat, bool includeDetails,
IEnumerable <DocumentBaseType> otherInputDocuments = null)
{
if (signature == null)
{
throw new ArgumentNullException("signature", "El valor no puede ser nulo.");
}
object document = GetDocument(signature, signatureFormat);
DocumentType doc = new DocumentType();
doc.ID = "ID_DOCUMENTO";
doc.Item = document;
SignatureObject signatureObject = new SignatureObject();
signatureObject.Item = new SignaturePtr()
{
WhichDocument = "ID_DOCUMENTO"
};
List <DocumentBaseType> documents = new List <DocumentBaseType>();
documents.Add(doc);
if (otherInputDocuments != null)
{
foreach (var inputDocument in otherInputDocuments)
{
documents.Add(inputDocument);
}
}
IgnoreGracePeriod igp = new IgnoreGracePeriod();
ReturnVerificationReport verificationReport = new ReturnVerificationReport();
verificationReport.ReportOptions = new ReportOptionsType();
if (includeDetails)
{
verificationReport.ReportOptions.ReportDetailLevel = "urn:oasis:names:tc:dss:1.0:reportdetail:allDetails";
}
else
{
verificationReport.ReportOptions.ReportDetailLevel = "urn:oasis:names:tc:dss:1.0:reportdetail:noDetails";
}
VerifyRequest request = BuildRequest(documents, signatureObject, new XmlElement[] { GetXmlElement(igp), GetXmlElement(verificationReport) });
DSSAfirmaVerifyService ds = new DSSAfirmaVerifyService(_identity, _serverCert);
string result = ds.verify(GetXmlElement(request).OuterXml);
VerifyResponse response = DeserializeXml <VerifyResponse>(result);
if (ResultType.RequesterError.Equals(response.Result.ResultMajor) ||
ResultType.ResponderError.Equals(response.Result.ResultMajor))
{
throw new AfirmaResultException(response.Result.ResultMajor, response.Result.ResultMinor, response.Result.ResultMessage.Value);
}
return(response);
}
/// <summary> /// 修改用户资料， （管理员接口） /// </summary> /// <returns></returns> public abstract bool AdminUpdateUserProfile(int userID, string realname, string email, Gender gender, DateTime birthday, bool isActive, bool emailValidated, string signature, SignatureFormat signatureFormat, UserExtendedValueCollection extendedFields);
private static IReadOnlyList <string> ParseArgumentList(Tokenizer tokenizer, TokenType endToken, SignatureFormat signatureFormat)
{
List <string> args = new List <string>();
do
{
bool hasArg = NextArgType(tokenizer, signatureFormat, endToken, out var argType);
if (hasArg)
{
args.Add(argType);
var t = tokenizer.Peek();
if (!t.HasValue)
{
throw new FormatException("Expected ')' found EOF");
}
if (t.Value.Kind == endToken)
{
return(args);
}
tokenizer.Expect(TokenType.Comma);
}
else
{
return(args);
}
} while (true);
}
public bool Verify(Hash256 hash, SignatureByte signature, Network network)
{
var data = SignatureEngine.FormatMessageForSigning(hash.Bytes, network);
return(ECDSAKey.Verify(data, SignatureFormat.FromBytes(signature)));
}
