public ServiceMetadata GetServiceMetadata( ParticipantIdentifier participantIdentifier, DocumentTypeIdentifier documentTypeIdentifier) // throws LookupException, PeppolSecurityException { Uri location = this.locator.Lookup(participantIdentifier); Uri providerUrl = this.provider.ResolveServiceMetadata( location, participantIdentifier, documentTypeIdentifier); FetcherResponse fetcherResponse; try { fetcherResponse = this.fetcher.Fetch(providerUrl); } catch (FileNotFoundException e) { throw new LookupException( $"Combination of receiver ({participantIdentifier}) and " + $"document type identifier ({documentTypeIdentifier}) is not supported.", e); } IPotentiallySigned <ServiceMetadata> serviceMetadata = this.reader.ParseServiceMetadata(fetcherResponse); if (serviceMetadata is Signed <ServiceMetadata> ) { this.validator.Validate(Service.Smp, ((Signed <ServiceMetadata>)serviceMetadata).Certificate); } return(serviceMetadata.Content); }
public static Header Read(StandardBusinessDocumentHeader sbdh) // throws SbdhException { Header header = Header.NewInstance(); // Sender PartnerIdentification senderIdentifier = sbdh.Sender[0].Identifier; header = header.SetSender( ParticipantIdentifier.Of(senderIdentifier.Value, Scheme.Of(senderIdentifier.Authority))); // Receiver PartnerIdentification receiverIdentifier = sbdh.Receiver[0].Identifier; header = header.SetReceiver( ParticipantIdentifier.Of(receiverIdentifier.Value, Scheme.Of(receiverIdentifier.Authority))); // Identifier header = header.SetIdentifier(InstanceIdentifier.Of(sbdh.DocumentIdentification.InstanceIdentifier)); // InstanceType header = header.SetInstanceType( InstanceType.Of( sbdh.DocumentIdentification.Standard, sbdh.DocumentIdentification.Type, sbdh.DocumentIdentification.TypeVersion)); // CreationTimestamp if (sbdh.DocumentIdentification.CreationDateAndTime == null) { throw new SbdhException("Element 'CreationDateAndTime' is not set or contains invalid value."); } header = header.SetCreationTimestamp(sbdh.DocumentIdentification.CreationDateAndTime); // Scope foreach (Scope scope in sbdh.BusinessScope) { if (scope.Type.Equals("DOCUMENTID")) { Scheme scheme = scope.Identifier != null ? Scheme.Of(scope.Identifier) : DocumentTypeIdentifier.DefaultScheme; header = header.SetDocumentType(DocumentTypeIdentifier.Of(scope.InstanceIdentifier, scheme)); } else if (scope.Type.Equals("PROCESSID")) { Scheme scheme = scope.Identifier != null ? Scheme.Of(scope.Identifier) : ProcessIdentifier.DefaultScheme; header = header.SetProcess(ProcessIdentifier.Of(scope.InstanceIdentifier, scheme)); } } return(header); }
public IPotentiallySigned <ServiceMetadata> ParseServiceMetadata(FetcherResponse fetcherResponse) { try { XmlDocument doc = new XmlDocument(); doc.Load(fetcherResponse.InputStream); var o = ClassFactory.FromXmlStream(fetcherResponse.InputStream); X509Certificate signer = null; if (o is SignedServiceMetadata) { signer = XmldsigVerifier.Verify(doc); } ServiceInformationType serviceInformation = ((tns.ServiceMetadata)o).ServiceInformation; List <ProcessMetadata <Endpoint> > processMetadatas = new List <ProcessMetadata <Endpoint> >(); foreach (ProcessType processType in serviceInformation.ProcessList.Process) { List <Endpoint> endpoints = new List <Endpoint>(); foreach (EndpointType endpointType in processType.ServiceEndpointList.Endpoint) { endpoints.Add( Endpoint.Of( TransportProfile.Of(endpointType.TransportProfile), new Uri(endpointType.EndpointURI), this.CertificateInstance(endpointType.Certificate.Data))); } processMetadatas.Add( ProcessMetadata <Endpoint> .Of( ProcessIdentifier.Of( processType.ProcessIdentifier.PrimitiveValue, Scheme.Of(processType.ProcessIdentifier.Scheme)), endpoints)); } return(Signed <ServiceMetadata> .Of( ServiceMetadata.Of( ParticipantIdentifier.Of( serviceInformation.ParticipantIdentifier.PrimitiveValue, Scheme.Of(serviceInformation.ParticipantIdentifier.Scheme)), DocumentTypeIdentifier.Of( serviceInformation.DocumentIdentifier.PrimitiveValue, Scheme.Of(serviceInformation.DocumentIdentifier.Scheme)), processMetadatas), signer)); } catch (Exception e) when(e is CertificateException | e is IOException) { throw new Exception(e.Message, e); } }
public Endpoint GetEndpoint( ParticipantIdentifier participantIdentifier, DocumentTypeIdentifier documentTypeIdentifier, ProcessIdentifier processIdentifier, TransportProfile[] transportProfiles) // throws LookupException, PeppolSecurityException, EndpointNotFoundException { ServiceMetadata serviceMetadata = this.GetServiceMetadata(participantIdentifier, documentTypeIdentifier); return(this.GetEndpoint(serviceMetadata, processIdentifier, transportProfiles)); }
public Uri ResolveServiceMetadata( Uri location, ParticipantIdentifier participantIdentifier, DocumentTypeIdentifier documentTypeIdentifier) { var relativeUriText = $"/{participantIdentifier.Urlencoded()}/services/{documentTypeIdentifier.Urlencoded()}"; var relativeUri = new Uri(relativeUriText, UriKind.Relative); return(new Uri(location, relativeUri)); }
public static Scope CreateScope(DocumentTypeIdentifier documentTypeIdentifier) { Scope scope = new Scope(); scope.Type = "DOCUMENTID"; scope.InstanceIdentifier = documentTypeIdentifier.Identifier; if (!documentTypeIdentifier.Scheme.Equals(DocumentTypeIdentifier.DefaultScheme)) { scope.Identifier = documentTypeIdentifier.Scheme.Identifier; } return(scope); }
public IPotentiallySigned <ServiceMetadata> ParseServiceMetadata(FetcherResponse fetcherResponse) { try { XmlDocument doc = new XmlDocument(); doc.PreserveWhitespace = true; doc.Load(fetcherResponse.InputStream); var o = ClassFactory.FromXmlElement(doc.DocumentElement); Xml.Busdox.tns.ServiceMetadata serviceMetadata = o as Xml.Busdox.tns.ServiceMetadata; X509Certificate signer = null; if (o is SignedServiceMetadata) { signer = XmldsigVerifier.Verify(doc); serviceMetadata = ((SignedServiceMetadata)o).ServiceMetadata; } if (serviceMetadata == null) { throw new LookupException("ServiceMetadata element not found"); } ServiceInformationType serviceInformation = serviceMetadata.ServiceInformation; List <ProcessMetadata <Endpoint> > processMetadatas = new List <ProcessMetadata <Endpoint> >(); foreach (ProcessType processType in serviceInformation.ProcessList.Process) { List <Endpoint> endpoints = new List <Endpoint>(); foreach (EndpointType endpointType in processType.ServiceEndpointList.Endpoint) { var certificate = this.CertificateInstance(Convert.FromBase64String(endpointType.Certificate)); var endpointUri = new Uri(endpointType.EndpointReference.Address.PrimitiveValue); var profile = TransportProfile.Of(endpointType.TransportProfile); endpoints.Add(Endpoint.Of(profile, endpointUri, certificate)); } processMetadatas.Add( ProcessMetadata <Endpoint> .Of( ProcessIdentifier.Of( processType.ProcessIdentifier.PrimitiveValue, Scheme.Of(processType.ProcessIdentifier.Scheme)), endpoints)); } return(Signed <ServiceMetadata> .Of( ServiceMetadata.Of( ParticipantIdentifier.Of( serviceInformation.ParticipantIdentifier.PrimitiveValue, Scheme.Of(serviceInformation.ParticipantIdentifier.Scheme)), DocumentTypeIdentifier.Of( serviceInformation.DocumentIdentifier.PrimitiveValue, Scheme.Of(serviceInformation.DocumentIdentifier.Scheme)), processMetadatas), signer)); } catch (Exception e) when(e is CertificateException | e is IOException) { throw new Exception(e.Message, e); } }
public TransmissionRequestBuilder DocumentType(DocumentTypeIdentifier documentTypeIdentifier) { this.suppliedHeaderFields.DocumentTypeIdentifier = documentTypeIdentifier; return(this); }
public XmlDocument CreateXml(IList <SmpService> services) { var firstService = services.First(); var participant = Peppol.Common.Model.ParticipantIdentifier.Parse(firstService.PeppolParticipant.Identifier); var documentType = DocumentTypeIdentifier.Parse(firstService.PeppolDocument.Identifier); var signedServiceMetadata = new SignedServiceMetadata(); var serviceMetadata = new ServiceMetadata(); signedServiceMetadata.ServiceMetadata = serviceMetadata; var serviceInfo = new ServiceInformationType(); serviceMetadata.ServiceInformation = serviceInfo; serviceInfo.ParticipantIdentifier = new ParticipantIdentifier(); serviceInfo.ParticipantIdentifier.Scheme = participant.Scheme.Identifier; serviceInfo.ParticipantIdentifier.PrimitiveValue = participant.Identifier; serviceInfo.DocumentIdentifier = new DocumentIdentifier(); serviceInfo.DocumentIdentifier.Scheme = documentType.Scheme.Identifier; serviceInfo.DocumentIdentifier.PrimitiveValue = documentType.Identifier; serviceInfo.ProcessList = new ProcessListType(); foreach (var service in services) { var process = new ProcessType(); serviceInfo.ProcessList.Process.Add(process); var processIdentifier = Peppol.Common.Model.ProcessIdentifier.Parse(service.PeppolProcess.Identifier); process.ProcessIdentifier = new ProcessIdentifier(); process.ProcessIdentifier.Scheme = processIdentifier.Scheme.Identifier; process.ProcessIdentifier.PrimitiveValue = processIdentifier.Identifier; process.ServiceEndpointList = new ServiceEndpointList(); foreach (var endpoint in service.Endpoints) { var xEndpoint = new EndpointType(); xEndpoint.EndpointReference = new EndpointReference(); xEndpoint.EndpointReference.Address.PrimitiveValue = endpoint.Endpoint; xEndpoint.EndpointReference.ReferenceParameters = new ReferenceParameters(); xEndpoint.EndpointReference.Metadata = new Metadata(); xEndpoint.TransportProfile = "busdox-transport-as2-ver1p0"; xEndpoint.Certificate = endpoint.Certificate; xEndpoint.MinimumAuthenticationLevel = endpoint.MinimumAuthenticationLevel; xEndpoint.RequireBusinessLevelSignature = endpoint.RequireBusinessLevelSignature; xEndpoint.ServiceExpirationDate = new XmlDateTime(endpoint.ServiceExpirationDate); xEndpoint.ServiceActivationDate = new XmlDateTime(endpoint.ServiceActivationDate); xEndpoint.ServiceDescription = endpoint.ServiceDescription; xEndpoint.TechnicalContactUrl = endpoint.TechnicalContactUrl; process.ServiceEndpointList.Endpoint.Add(xEndpoint); } } var certPath = "conf\\test-keystore.pfx"; var certPass = "******"; var collection = new X509Certificate2Collection(); collection.Import(certPath, certPass, X509KeyStorageFlags.PersistKeySet); AsymmetricAlgorithm key = null; X509Certificate cert = null; foreach (var certificate in collection) { if (certificate.HasPrivateKey) { key = certificate.PrivateKey; cert = certificate; } } signedServiceMetadata.Signature = new Xml.Busdox.ds.Signature(); signedServiceMetadata.Signature.SignedInfo = new Xml.Busdox.ds.SignedInfo(); signedServiceMetadata.Signature.SignedInfo.Reference.Add(new Xml.Busdox.ds.Reference()); var xmlRoot = signedServiceMetadata.ToXmlElement(true, Encoding.UTF8, EOLType.CRLF); xmlRoot.RemoveChild(xmlRoot.LastChild); var xmlDoc = new XmlDocument(); xmlDoc.PreserveWhitespace = true; xmlDoc.LoadXml(xmlRoot.OuterXml); var signedXml = new SignedXml(xmlDoc); signedXml.SigningKey = key; var reference = new Reference(); reference.Uri = ""; var env = new XmlDsigEnvelopedSignatureTransform(); reference.AddTransform(env); signedXml.AddReference(reference); signedXml.ComputeSignature(); signedXml.KeyInfo = new KeyInfo(); var keyClause = new KeyInfoX509Data(cert); Debug.Assert(cert != null, nameof(cert) + " != null"); keyClause.AddSubjectName(cert.Subject); signedXml.KeyInfo.AddClause(keyClause); var xmlDigitalSignature = signedXml.GetXml(); xmlDoc.DocumentElement.AppendChild(xmlDoc.ImportNode(xmlDigitalSignature, true)); return(xmlDoc); }
public DocumentTypeIdentifier ToVefa() { return(DocumentTypeIdentifier.Of(this.ToString())); }
private static void RunInScope(ILifetimeScope scope, Options options) { // bootstraps the outbound module HyperwayOutboundComponent hyperwayOutboundComponent = scope.Resolve <HyperwayOutboundComponent>(); TransmissionParameters parameters = new TransmissionParameters(hyperwayOutboundComponent); // Verifies the existence of a directory in which transmission evidence is stored. DirectoryInfo evidencePath = options.Evidence == null ? null : new DirectoryInfo(options.Evidence); if (evidencePath == null) { evidencePath = new DirectoryInfo("."); // Default is current directory } if (!evidencePath.Exists) { PrintErrorMessage(evidencePath + " does not exist or is not a directory"); } parameters.EvidencePath = evidencePath; // --- Use Factory parameters.UseFactory = options.UseRequestFactory; // --- Recipient String recipientId = options.Recipient; if (recipientId != null) { parameters.Receiver = ParticipantIdentifier.Of(recipientId); } // --- Sender String senderId = options.Sender; if (senderId != null) { parameters.Sender = ParticipantIdentifier.Of(senderId); } // --- Document type var docType = options.DocumentType; if (docType != null) { String value = options.DocumentType; parameters.DocType = DocumentTypeIdentifier.Of(value); } // --- Process type var profileType = options.ProfileType; if (profileType != null) { String value = options.ProfileType; // profileType.value(optionSet); parameters.ProcessIdentifier = ProcessIdentifier.Of(value); } // --- Probe if (options.Probe) { WebClient c = new WebClient(); var url = options.DestinationUrl; var output = c.DownloadData(url); Console.WriteLine(System.Text.Encoding.UTF8.GetString(output)); } else { // --- Destination URL, protocl and system identifier if (!string.IsNullOrEmpty(options.DestinationUrl) && !options.Probe) { String destinationString = options.DestinationUrl; X509Certificate certificate; using (Stream inputStream = File.Open(options.DestinationCertificate, FileMode.Open, FileAccess.Read)) { certificate = Validator.GetCertificate(inputStream); } parameters.Endpoint = Endpoint.Of( TransportProfile.AS2_1_0, new Uri(destinationString), certificate); } // Retrieves the name of the file to be transmitted IEnumerable <string> payloadFileSpec = options.InputFiles; List <FileInfo> files = LocateFiles(payloadFileSpec); Console.WriteLine(""); Console.WriteLine(""); int maxThreads = options.ThreadCount; Log.Info("Using " + maxThreads + " threads"); int repeats = options.RepeatCount; int maximumTransmissions = options.MaxTransmissions; // ExecutorService exec = Executors.newFixedThreadPool(maxThreads); // ExecutorCompletionService<TransmissionResult> ecs = new ExecutorCompletionService<>(exec); // long start = DateTime.Now; int submittedTaskCount = 0; foreach (FileInfo file in files) { //if (!file.isFile() || !file.canRead()) { // log.error("File " + file + " is not a file or can not be read, skipping..."); // continue; //} for (int i = 0; i < repeats; i++) { TransmissionTask transmissionTask = new TransmissionTask(parameters, file); transmissionTask.Call(); //Future<TransmissionResult> submit = ecs.submit(transmissionTask); //submittedTaskCount++; //if (submittedTaskCount > maximumTransmissions) { // log.Info("Stopped submitting tasks at {} " + submittedTaskCount); // break; //} } if (submittedTaskCount > maximumTransmissions) { break; } } // Wait for the results to be available //List<TransmissionResult> results = new List<TransmissionResult>(); //int failed = 0; //for (int i = 0; i<submittedTaskCount; i++) { // try { // Future<TransmissionResult> future = ecs.take(); // TransmissionResult transmissionResult = future.get(); // results.add(transmissionResult); // } catch (InterruptedException e) { // System.err.println(e.getMessage()); // } catch (ExecutionException e) { // log.error("Execution failed: {}", e.getMessage(), e); // failed++; // } //} //long elapsed = System.nanoTime() - start; //exec.shutdownNow(); // Shuts down the executor service //foreach (TransmissionResult transmissionResult in results) { // TransmissionIdentifier transmissionIdentifier = transmissionResult.getTransmissionIdentifier(); // System.out.println(transmissionIdentifier + " transmission took " + transmissionResult.getDuration() + "ms"); //} //OptionalDouble average = results.stream().mapToLong(TransmissionResult::getDuration).average(); //if (average.isPresent()) { // System.out.println("Average transmission time was " + average.getAsDouble() + "ms"); //} //long elapsedInSeconds = TimeUnit.SECONDS.convert(elapsed, TimeUnit.NANOSECONDS); //Console.WriteLine("Total time spent: " + elapsedInSeconds + "s"); //Console.WriteLine("Attempted to send " + results.size() + " files"); //Console.WriteLine("Failed transmissions: " + failed); //if (results.size() > 0 && elapsedInSeconds > 0) { // System.out.println("Transmission speed " + results.size() / elapsedInSeconds + " documents per second"); //} //Thread.sleep(2000); } }
public T DocumentType(DocumentTypeIdentifier value) { this.peppolDocumentTypeId = value; return(this.GetThis()); }
public HeaderStub(Header header) { this.receiver = header.Receiver; this.documentType = header.DocumentType; this.process = header.Process; }