public void Download_source()
        {
            var testProduct = new TestProduct("Тестовый продукт");

            session.Save(testProduct);
            var product = Product.Find(testProduct.Id);

            var source = new KatrenSource();

            var certificateSource = new CertificateSource();

            certificateSource.SourceClassName = source.GetType().Name;
            session.Save(certificateSource);

            var line = new DocumentLine {
                ProductEntity = product,
                SerialNumber  = "012011",
            };

            var sourceCatalog = new CertificateSourceCatalog {
                CertificateSource    = certificateSource,
                SerialNumber         = line.SerialNumber,
                CatalogProduct       = product.CatalogProduct,
                SupplierCode         = "34266440",
                SupplierProducerCode = "13483667",
                OriginFilePath       = KatrenSource.ToOriginFileName(0x1B9EFC8),
            };

            session.Save(sourceCatalog);

            var task  = new CertificateTask(certificateSource, line);
            var files = source.GetCertificateFiles(task, null);

            Assert.That(files.Count, Is.EqualTo(4));
        }
Exemple #2
0
        /// <exception cref="System.IO.IOException"></exception>
        public virtual ValidationContext ValidateCertificate(X509Certificate cert, DateTime
                                                             validationDate, CertificateSource optionalCertificateSource, ICrlSource optionalCRLSource
                                                             , IOcspSource optionalOCSPSource)
        {
            if (cert == null || validationDate == null)
            {
                throw new ArgumentNullException("A validation context must contains a cert and a validation date"
                                                );
            }
            ValidationContext previous = validationContextThreadLocal.Value;

            if (previous != null && previous.GetCertificate().Equals(cert) && previous.GetValidationDate
                    ().Equals(validationDate))
            {
                //LOG.Info("We don't need to check twice for the same");
                return(previous);
            }
            ValidationContext context = new ValidationContext(cert, validationDate);

            context.SetCrlSource(CrlSource);
            context.SetOcspSource(OcspSource);
            context.SetTrustedListCertificatesSource(TrustedListCertificatesSource);
            context.Validate(validationDate, optionalCertificateSource, optionalCRLSource, optionalOCSPSource
                             );
            validationContextThreadLocal.Value = context;
            return(context);
        }
Exemple #3
0
        public static X509Certificate2 GetCertificate(CertificateSource source, string value)
        {
            ArgCheck.NotNullOrDefault(nameof(source), source);
            ArgCheck.NotNullOrEmpty(nameof(value), value);

            if (source == CertificateSource.FileName)
            {
                var fileName = value;
                if (!File.Exists(fileName))
                {
                    throw new ArgumentException($"Certificate at {fileName} not found.", nameof(fileName));
                }
                return(new X509Certificate2(fileName));
            }

            if (source == CertificateSource.Thumbprint)
            {
                var thumbprint = value;
                using (var store = new X509Store(StoreName.My, StoreLocation.CurrentUser))
                {
                    store.Open(OpenFlags.ReadOnly);
                    var certs = store.Certificates.Find(X509FindType.FindByThumbprint, thumbprint, false);
                    if (certs.Count == 0)
                    {
                        throw new ArgumentException($"Certificate with thumbprint {thumbprint} not found.", nameof(thumbprint));
                    }
                    return(certs[0]);
                }
            }

            throw new ArgumentOutOfRangeException(nameof(source), $"Parameter {nameof(source)} is not a valid value.");
        }
        public void TestLoadAllCertificates(
            CertificateSource certificateSource,
            string container,
            string referenceOrValue)
        {
            List <CertificateDescription> certDescriptions = CreateCertificateDescriptions(
                certificateSource,
                container,
                referenceOrValue).ToList();

            certDescriptions.Add(new CertificateDescription
            {
                SourceType       = certificateSource,
                Container        = container,
                ReferenceOrValue = referenceOrValue,
            });

            certDescriptions.Add(CertificateDescription.FromCertificate(null));

            IEnumerable <X509Certificate2> certificates = DefaultCertificateLoader.LoadAllCertificates(certDescriptions);

            Assert.NotNull(certificates);
            Assert.Equal(2, certificates.Count());
            Assert.Equal(3, certDescriptions.Count);
            Assert.Equal("CN=ACS2ClientCertificate", certificates.First().Issuer);
            Assert.Equal("CN=ACS2ClientCertificate", certificates.Last().Issuer);
            Assert.Null(certDescriptions.ElementAt(2).Certificate);
        }
        private void UpdateInputFileProperties(ReadDesigner designer, IFunctionData data)
        {
            designer.Properties[PropertyNames.PdfFilePath].Value = data.Properties["Pdf filename"].Value;

            AuthenticationType authenticationType = data.Properties["Authentication type"].GetValue <AuthenticationType>();

            designer.Properties[PropertyNames.AuthenticationType].Value = authenticationType;
            switch (authenticationType)
            {
            case AuthenticationType.Password:
                designer.Properties[PropertyNames.PdfPassword].Value = data.Properties["Pdf password"].Value;
                break;

            case AuthenticationType.Certificate:
                CertificateSource certificateSource = data.Properties["Certificate source"].GetValue <CertificateSource>();
                designer.Properties[PropertyNames.CertificateSource].Value = certificateSource;
                switch (certificateSource)
                {
                case CertificateSource.File:
                    designer.Properties[PropertyNames.CertificateFilePath].Value     = data.Properties["Certificate file path"].Value;
                    designer.Properties[PropertyNames.CertificateFilePassword].Value = data.Properties["Certificate file password"].Value;
                    break;

                case CertificateSource.Store:
                    designer.Properties[PropertyNames.Certificate].Value = data.Properties["Certificate"].Value;
                    break;
                }
                break;
            }
        }
 /// <summary>Validate the timestamp</summary>
 /// <param name="timestamp"></param>
 /// <param name="optionalSource"></param>
 /// <param name="optionalCRLSource"></param>
 /// <param name="optionalOCPSSource"></param>
 /// <exception cref="System.IO.IOException"></exception>
 public virtual void ValidateTimestamp(TimestampToken timestamp, CertificateSource
                                       optionalSource, ICrlSource optionalCRLSource, IOcspSource optionalOCPSSource)
 {
     AddNotYetVerifiedToken(timestamp);
     Validate(timestamp.GetTimeStamp().TimeStampInfo.GenTime, new CompositeCertificateSource
                  (timestamp.GetWrappedCertificateSource(), optionalSource), optionalCRLSource, optionalOCPSSource
              );
 }
Exemple #7
0
        /// <exception cref="System.IO.IOException"></exception>
        //private IDictionary<DerObjectIdentifier, Asn1Encodable> ExtendUnsignedAttributes(IDictionary
        //    <DerObjectIdentifier, Asn1Encodable> unsignedAttrs, X509Certificate signingCertificate
        //    , DateTime signingDate, CertificateSource optionalCertificateSource)
        private IDictionary ExtendUnsignedAttributes(IDictionary unsignedAttrs
                                                     , X509Certificate signingCertificate, DateTime signingDate
                                                     , CertificateSource optionalCertificateSource)
        {
            ValidationContext validationContext = certificateVerifier.ValidateCertificate(signingCertificate
                                                                                          , signingDate, optionalCertificateSource, null, null);

            try
            {
                IList <X509CertificateStructure> certificateValues = new AList <X509CertificateStructure
                                                                                >();
                AList <CertificateList>   crlValues  = new AList <CertificateList>();
                AList <BasicOcspResponse> ocspValues = new AList <BasicOcspResponse>();
                foreach (CertificateAndContext c in validationContext.GetNeededCertificates())
                {
                    if (!c.Equals(signingCertificate))
                    {
                        certificateValues.AddItem(X509CertificateStructure.GetInstance(((Asn1Sequence)Asn1Object.FromByteArray
                                                                                            (c.GetCertificate().GetEncoded()))));
                    }
                }
                foreach (X509Crl relatedcrl in validationContext.GetNeededCRL())
                {
                    crlValues.AddItem(CertificateList.GetInstance((Asn1Sequence)Asn1Object.FromByteArray(((X509Crl
                                                                                                           )relatedcrl).GetEncoded())));
                }
                foreach (BasicOcspResp relatedocspresp in validationContext.GetNeededOCSPResp())
                {
                    ocspValues.AddItem((BasicOcspResponse.GetInstance((Asn1Sequence)Asn1Object.FromByteArray(
                                                                          relatedocspresp.GetEncoded()))));
                }
                CertificateList[]   crlValuesArray   = new CertificateList[crlValues.Count];
                BasicOcspResponse[] ocspValuesArray  = new BasicOcspResponse[ocspValues.Count];
                RevocationValues    revocationValues = new RevocationValues(Sharpen.Collections.ToArray
                                                                                (crlValues, crlValuesArray), Sharpen.Collections.ToArray(ocspValues, ocspValuesArray
                                                                                                                                         ), null);
                //unsignedAttrs.Put(PkcsObjectIdentifiers.IdAAEtsRevocationValues, new Attribute
                unsignedAttrs.Add(PkcsObjectIdentifiers.IdAAEtsRevocationValues, new BcCms.Attribute
                                      (PkcsObjectIdentifiers.IdAAEtsRevocationValues, new DerSet(revocationValues))
                                  );
                X509CertificateStructure[] certValuesArray = new X509CertificateStructure[certificateValues
                                                                                          .Count];
                //unsignedAttrs.Put(PkcsObjectIdentifiers.IdAAEtsCertValues, new Attribute(PkcsObjectIdentifiers.IdAAEtsCertValues, new DerSet(new DerSequence(Sharpen.Collections.ToArray(certificateValues
                unsignedAttrs.Add(PkcsObjectIdentifiers.IdAAEtsCertValues, new BcCms.Attribute(PkcsObjectIdentifiers.IdAAEtsCertValues, new DerSet(new DerSequence(Sharpen.Collections.ToArray(certificateValues
                                                                                                                                                                                               , certValuesArray)))));
            }
            catch (CertificateEncodingException e)
            {
                throw new RuntimeException(e);
            }
            catch (CrlException e)
            {
                throw new RuntimeException(e);
            }
            return(unsignedAttrs);
        }
Exemple #8
0
        private AuthenticationType UpdateProtectProtectionProperties(PdfOperationsDesigner designer, IFunctionData data)
        {
#pragma warning disable 618
            Obsolete.Protection oldProtection         = data.Properties["Output pdf protection"].GetValue <Obsolete.Protection>();
            AuthenticationType  newAuthenticationType = 0;
            switch (oldProtection)
            {
            case Obsolete.Protection.None:
                newAuthenticationType = AuthenticationType.None;
                break;

            case Obsolete.Protection.Password:
                newAuthenticationType = AuthenticationType.Password;
                break;

            case Obsolete.Protection.Certificate:
                newAuthenticationType = AuthenticationType.Certificate;
                break;
            }
#pragma warning restore 618

            designer.Properties[PropertyNames.ProtectProtection].Value = newAuthenticationType;
            switch (newAuthenticationType)
            {
            case AuthenticationType.Password:
                bool addDocumentRestrictions = data.Properties["Allow user access"].GetValue <bool>();
                if (addDocumentRestrictions)
                {
                    designer.Properties[PropertyNames.ProtectDocumentOpenPassword].Value = data.Properties["User password"].Value;
                }
                else
                {
                    designer.Properties[PropertyNames.ProtectDocumentOpenPassword].Value = data.Properties["Owner password"].Value;
                }
                break;

            case AuthenticationType.Certificate:
                CertificateSource certificateSource = data.Properties["Certificate source"].GetValue <CertificateSource>();
                designer.Properties[PropertyNames.ProtectCertificateSource].Value = certificateSource;
                switch (certificateSource)
                {
                case CertificateSource.File:
                    designer.Properties[PropertyNames.ProtectCertificateFilePath].Value     = data.Properties["Certificate file path"].Value;
                    designer.Properties[PropertyNames.ProtectCertificateFilePassword].Value = data.Properties["Certificate file password"].Value;
                    break;

                case CertificateSource.Store:
                    designer.Properties[PropertyNames.ProtectCertificate].Value = data.Properties["Certificate"].Value;
                    break;
                }
                break;
            }

            return(newAuthenticationType);
        }
Exemple #9
0
		/// <exception cref="System.IO.IOException"></exception>
        //private IDictionary<DerObjectIdentifier, Asn1Encodable> ExtendUnsignedAttributes(IDictionary
        //    <DerObjectIdentifier, Asn1Encodable> unsignedAttrs, X509Certificate signingCertificate
        //    , DateTime signingDate, CertificateSource optionalCertificateSource)
        private IDictionary ExtendUnsignedAttributes(IDictionary unsignedAttrs
            , X509Certificate signingCertificate, DateTime signingDate
            , CertificateSource optionalCertificateSource)
		{
			ValidationContext validationContext = certificateVerifier.ValidateCertificate(signingCertificate
				, signingDate, optionalCertificateSource, null, null);
			try
			{
				IList<X509CertificateStructure> certificateValues = new AList<X509CertificateStructure
					>();
				AList<CertificateList> crlValues = new AList<CertificateList>();
				AList<BasicOcspResponse> ocspValues = new AList<BasicOcspResponse>();
				foreach (CertificateAndContext c in validationContext.GetNeededCertificates())
				{
					if (!c.Equals(signingCertificate))
					{
                        certificateValues.AddItem(X509CertificateStructure.GetInstance(((Asn1Sequence)Asn1Object.FromByteArray
                            (c.GetCertificate().GetEncoded()))));
					}
				}
				foreach (X509Crl relatedcrl in validationContext.GetNeededCRL())
				{                    
					crlValues.AddItem(CertificateList.GetInstance((Asn1Sequence)Asn1Object.FromByteArray(((X509Crl
						)relatedcrl).GetEncoded())));
				}
				foreach (BasicOcspResp relatedocspresp in validationContext.GetNeededOCSPResp())
				{                    
					ocspValues.AddItem((BasicOcspResponse.GetInstance((Asn1Sequence)Asn1Object.FromByteArray(
						relatedocspresp.GetEncoded()))));
				}
				CertificateList[] crlValuesArray = new CertificateList[crlValues.Count];
				BasicOcspResponse[] ocspValuesArray = new BasicOcspResponse[ocspValues.Count];
				RevocationValues revocationValues = new RevocationValues(Sharpen.Collections.ToArray
					(crlValues, crlValuesArray), Sharpen.Collections.ToArray(ocspValues, ocspValuesArray
					), null);
				//unsignedAttrs.Put(PkcsObjectIdentifiers.IdAAEtsRevocationValues, new Attribute
                unsignedAttrs.Add(PkcsObjectIdentifiers.IdAAEtsRevocationValues, new BcCms.Attribute
					(PkcsObjectIdentifiers.IdAAEtsRevocationValues, new DerSet(revocationValues))
					);
				X509CertificateStructure[] certValuesArray = new X509CertificateStructure[certificateValues
					.Count];
				//unsignedAttrs.Put(PkcsObjectIdentifiers.IdAAEtsCertValues, new Attribute(PkcsObjectIdentifiers.IdAAEtsCertValues, new DerSet(new DerSequence(Sharpen.Collections.ToArray(certificateValues
                unsignedAttrs.Add(PkcsObjectIdentifiers.IdAAEtsCertValues, new BcCms.Attribute(PkcsObjectIdentifiers.IdAAEtsCertValues, new DerSet(new DerSequence(Sharpen.Collections.ToArray(certificateValues
					, certValuesArray)))));
			}
			catch (CertificateEncodingException e)
			{
				throw new RuntimeException(e);
			}
			catch (CrlException e)
			{
				throw new RuntimeException(e);
			}
			return unsignedAttrs;
		}
Exemple #10
0
 private static void CreateFiles(CertificateSource certificateSource, Certificate certificate, int count)
 {
     for (var i = 0; i < count; i++)
     {
         certificate.NewFile(
             new CertificateFile {
             OriginFilename    = Path.GetRandomFileName(),
             CertificateSource = certificateSource,
             Extension         = ".tif"
         });
     }
 }
Exemple #11
0
 public void Get_local_file()
 {
     using (var cleaner = new FileCleaner()) {
         var tmpFile  = cleaner.TmpFile();
         var fileInfo = new FileInfo(tmpFile);
         fileInfo.LastWriteTime = DateTime.Now.AddDays(1);
         var source = new CertificateSource {
             DecodeTableUrl = new Uri(fileInfo.FullName).ToString()
         };
         var file = handler.GetCatalogFile(source, cleaner);
         Assert.IsNotNull(file);
     }
 }
Exemple #12
0
 /// <summary>An X509Certificate may contain information about his issuer in the AIA attribute.
 ///     </summary>
 /// <remarks>An X509Certificate may contain information about his issuer in the AIA attribute.
 ///     </remarks>
 public virtual CertificateSource GetWrappedCertificateSource()
 {
     if (sourceFactory != null)
     {
         CertificateSource source = sourceFactory.CreateAIACertificateSource(GetCertificate
                                                                                 ());
         return(source);
     }
     else
     {
         return(null);
     }
 }
Exemple #13
0
        public void SetUp()
        {
            session.DeleteEach <CertificateSource>();

            _supplier = TestSupplier.CreateNaked(session);
            _source   = new CertificateSource();
            _source.SourceClassName = "";
            _source.Suppliers.Add(session.Load <Supplier>(_supplier.Id));
            session.Save(_source);

            handler = new CertificateCatalogHandler();
            handler.CreateDownHandlerPath();
        }
Exemple #14
0
        private static Certificate CreateCertificateWithFiles(CertificateSource certificateSource,
                                                              TestCatalogProduct catalog,
                                                              string serialNumber)
        {
            var certificate = new Certificate();

            using (new TransactionScope()) {
                certificate.CatalogProduct = Catalog.Find(catalog.Id);
                certificate.SerialNumber   = serialNumber;
                CreateFiles(certificateSource, certificate, 2);
                certificate.Save();
            }
            return(certificate);
        }
        public static void InitializeCertificateProperties(
            this PropertyCollection properties,
            string certificateSourcePropertyName,
            string certificateFilePathPropertyName,
            string certificateFilePasswordPropertyName,
            string certificatePropertyName,
            ref int propertyOrder,
            VisibleDependency visibleDependency)
        {
            Action <bool> applyVisibility = (isVisible) =>
            {
                CertificateSource certificateSourceValue = properties[certificateSourcePropertyName].GetValue <CertificateSource>();

                properties[certificateSourcePropertyName].IsVisible       = isVisible;
                properties[certificateFilePathPropertyName].IsVisible     = (isVisible && certificateSourceValue == CertificateSource.File);
                properties[certificateFilePasswordPropertyName].IsVisible = (isVisible && certificateSourceValue == CertificateSource.File);
                properties[certificatePropertyName].IsVisible             = (isVisible && certificateSourceValue == CertificateSource.Store);
            };
            EventHandler updateVisibility = (sender, args) => applyVisibility(visibleDependency.Visible);

            visibleDependency.VisibleChanged += (visible) => applyVisibility(visible);

            Property certificateSource = properties.AddOrRetrieve(certificateSourcePropertyName, typeof(CertificateSource), ValueUseOption.DesignTime, CertificateSource.File);

            certificateSource.Order         = propertyOrder++;
            certificateSource.Description   = "Source to load the certificate from.";
            certificateSource.ValueChanged += updateVisibility;

            Property certificateFilePath = properties.AddOrRetrieve(certificateFilePathPropertyName, typeof(string), ValueUseOption.RuntimeRead, string.Empty);

            certificateFilePath.Order       = propertyOrder++;
            certificateFilePath.Description = "Path to the file containing a certificate.";
            certificateFilePath.Editor      = typeof(FilePathEditor);
            certificateFilePath.Validations.Add(new RequiredValidator());

            Property certificateFilePassword = properties.AddOrRetrieve(certificateFilePasswordPropertyName, typeof(string), ValueUseOption.RuntimeRead, string.Empty);

            certificateFilePassword.Order       = propertyOrder++;
            certificateFilePassword.Description = "Password required to open the certificate file.";

            Property certificate = properties.AddOrRetrieve(certificatePropertyName, typeof(StoredCertificate), ValueUseOption.DesignTime, new StoredCertificate());

            certificate.Order       = propertyOrder++;
            certificate.Description = "Certificate in the windows keystore.";
            certificate.Validations.Add(new StoredCertificateValidator());
            certificate.Editor = typeof(CertificateEditor);

            applyVisibility(visibleDependency.Visible);
        }
        public void TestLoadFirstCertificate(
            CertificateSource certificateSource,
            string container,
            string referenceOrValue)
        {
            IEnumerable <CertificateDescription> certDescriptions = CreateCertificateDescriptions(
                certificateSource,
                container,
                referenceOrValue);

            X509Certificate2 certificate = DefaultCertificateLoader.LoadFirstCertificate(certDescriptions);

            Assert.NotNull(certificate);
            Assert.Equal("CN=ACS2ClientCertificate", certificate.Issuer);
        }
        private IEnumerable <CertificateDescription> CreateCertificateDescriptions(
            CertificateSource certificateSource,
            string container,
            string referenceOrValue)
        {
            List <CertificateDescription> certificateDescription = new List <CertificateDescription>();

            certificateDescription.Add(new CertificateDescription
            {
                SourceType       = certificateSource,
                Container        = container,
                ReferenceOrValue = referenceOrValue,
            });

            return(certificateDescription);
        }
        public void TestDefaultCertificateLoader(CertificateSource certificateSource, string container, string referenceOrValue)
        {
            CertificateDescription certificateDescription;

            switch (certificateSource)
            {
            case CertificateSource.KeyVault:
                certificateDescription = CertificateDescription.FromKeyVault(container, referenceOrValue);
                break;

            case CertificateSource.Base64Encoded:
                certificateDescription = CertificateDescription.FromBase64Encoded(referenceOrValue);
                break;

            case CertificateSource.Path:
                certificateDescription = CertificateDescription.FromPath(container, referenceOrValue);
                break;

            case CertificateSource.StoreWithThumbprint:
                certificateDescription = new CertificateDescription()
                {
                    SourceType = CertificateSource.StoreWithThumbprint
                };
                certificateDescription.CertificateThumbprint = referenceOrValue;
                certificateDescription.CertificateStorePath  = container;
                break;

            case CertificateSource.StoreWithDistinguishedName:
                certificateDescription = new CertificateDescription()
                {
                    SourceType = CertificateSource.StoreWithDistinguishedName
                };
                certificateDescription.CertificateDistinguishedName = referenceOrValue;
                certificateDescription.CertificateStorePath         = container;
                break;

            default:
                certificateDescription = null;
                break;
            }

            ICertificateLoader loader = new DefaultCertificateLoader();

            loader.LoadIfNeeded(certificateDescription);

            Assert.NotNull(certificateDescription.Certificate);
        }
Exemple #19
0
        public void SetUp()
        {
            var supplier     = TestSupplier.Create();
            var realSupplier = Supplier.Find(supplier.Id);

            using (new TransactionScope()) {
                var certificateSources = CertificateSource.Queryable.Where(s => s.SourceClassName == typeof(RostaCertificateSource).Name).ToList();
                certificateSources.ForEach(c => c.Delete());

                _source = new CertificateSource {
                    SourceClassName = typeof(RostaCertificateSource).Name
                };
                _source.Suppliers = new List <Supplier>();
                _source.Suppliers.Add(realSupplier);
                _source.Save();
            }
        }
Exemple #20
0
        private void UpdateSignCertificateProperties(PdfOperationsDesigner designer, IFunctionData data)
        {
            CertificateSource certificateSource = data.Properties["Signing certificate source"].GetValue <CertificateSource>();

            designer.Properties[PropertyNames.SignCertificateSource].Value = certificateSource;
            switch (certificateSource)
            {
            case CertificateSource.File:
                designer.Properties[PropertyNames.SignCertificateFilePath].Value     = data.Properties["Signing certificate file path"].Value;
                designer.Properties[PropertyNames.SignCertificateFilePassword].Value = data.Properties["Signing certificate file password"].Value;
                break;

            case CertificateSource.Store:
                designer.Properties[PropertyNames.SignCertificate].Value = data.Properties["Signing certificate"].Value;
                break;
            }
        }
Exemple #21
0
        private CertificateSource CreateSourceForSupplier()
        {
            var source = CertificateSource.Queryable.FirstOrDefault(s => s.Suppliers.FirstOrDefault(certificateSupplier => certificateSupplier.Id == supplier.Id) != null);

            if (source == null)
            {
                using (new TransactionScope()) {
                    source = new CertificateSource {
                        SourceClassName = Path.GetRandomFileName()
                    };
                    source.Suppliers = new List <Supplier>();
                    source.Suppliers.Add(supplier);
                    source.Save();
                }
            }
            return(source);
        }
Exemple #22
0
        public static DomainCertificate FromX509Certificate2(X509Certificate2 cert, CertificateSource source)
        {
            if (cert == null)
            {
                return(null);
            }
            var publicPortion = cert.Export(X509ContentType.Cert);
            var rawData       = Convert.ToBase64String(publicPortion);
            var serial        = cert.GetSerialNumberString();
            var thumb         = cert.GetCertHashString();
            var issuer        = cert.GetNameInfo(X509NameType.DnsName, true);
            var subject       = cert.GetNameInfo(X509NameType.DnsName, false);

            if (string.IsNullOrWhiteSpace(issuer))
            {
                issuer = cert.Issuer;
            }
            if (string.IsNullOrWhiteSpace(subject))
            {
                if (cert.Subject.StartsWith("CN="))
                {
                    subject = cert.Subject.Substring(3);
                }
                else
                {
                    subject = cert.Subject;
                }
            }
            var domain     = DomainParser.RegistrableDomain(subject);
            var domainCert = new DomainCertificate
            {
                DateCreated       = DateTime.UtcNow,
                Subject           = subject,
                RegistrableDomain = domain,
                IssuerName        = issuer,
                RawData           = rawData,
                CertificateSource = source,
                SerialNumber      = serial,
                Thumbprint        = thumb,
                ValidNotAfter     = cert.NotAfter,
                ValidNotBefore    = cert.NotBefore
            };

            return(domainCert);
        }
        public ClientCertificateCredentialsFromFile(CertificateSource certificateSource, string certificateLocation)
        {
            if (!Enum.IsDefined(typeof(CertificateSource), certificateSource))
            {
                throw new ArgumentOutOfRangeException(nameof(certificateSource), $"{nameof(certificateSource)} contained an unexpected value.");
            }
            if (string.IsNullOrWhiteSpace(certificateLocation))
            {
                throw new ArgumentNullException(nameof(certificateLocation));
            }

            _certificateSource   = certificateSource;
            _certificateLocation = certificateLocation;

            ClientCertificate.Certificate = certificateSource == CertificateSource.EmbeddedResource ?
                                            GetCertificateFromEmbeddedResource(certificateLocation)
                    : GetCertificateFromDisk(certificateLocation);
        }
Exemple #24
0
        public void Set_sertificate_source()
        {
            var newCertificate = new CertificateSource {
                Name            = "Test_Source",
                SourceClassName = "Test_class_Name"
            };

            session.Save(newCertificate);

            Open(supplier);
            Css("#editChangerButton").Click();
            Css("select[name='sertificateSourceId']").SelectByValue(newCertificate.Id.ToString());
            Css("#saveCertificateSourceButton").Click();
            AssertText("Сохранено");
            session.Refresh(supplier);
            Assert.That(supplier.GetSertificateSource().Name, Is.StringContaining("Test_Source"));
            session.Delete(newCertificate);
        }
        public void SetUp()
        {
            _testSupplier = TestSupplier.Create();
            _realSupplier = session.Query <Supplier>().FirstOrDefault(s => s.Id == _testSupplier.Id);

            var certificateSources = session.Query <CertificateSource>().Where(s => s.SourceClassName == typeof(RostaCertificateSource).Name).ToList();

            certificateSources.ForEach(c => session.Delete(c));

            _source = new CertificateSource {
                SourceClassName = typeof(RostaCertificateSource).Name
            };
            _source.Suppliers = new List <Supplier>();
            _source.Suppliers.Add(_realSupplier);
            session.Save(_source);

            _testUser = TestClient.Create().Users[0];
        }
        private CertificateSource CreateSourceForSupplier(Supplier supplier, string sourceClassName)
        {
            var source = new CertificateSource {
                SourceClassName = sourceClassName
            };

            var deletedSource = CertificateSource.Queryable.FirstOrDefault(s => s.SourceClassName == sourceClassName);

            if (deletedSource != null)
            {
                deletedSource.Delete();
            }

            source.Suppliers = new List <Supplier>();
            source.Suppliers.Add(supplier);
            source.Save();

            return(source);
        }
        public void Load_file_without_dir()
        {
            FTP_Server server = null;

            try {
                server = new FTP_Server();
                var port = new Random().Next(10000, 20000);
                server.BindInfo = new[] { new BindInfo(BindInfoProtocol.TCP, IPAddress.Loopback, port), };
                server.StartServer();
                var testProduct = new TestProduct("Тестовый продукт");
                session.Save(testProduct);
                var product = session.Load <Product>(testProduct.Id);
                var line    = new DocumentLine {
                    ProductEntity = product,
                    SerialNumber  = "012011",
                };

                var source            = new KatrenSource();
                var certificateSource = new CertificateSource();
                certificateSource.SourceClassName = source.GetType().Name;
                session.Save(certificateSource);

                var sourceCatalog = new CertificateSourceCatalog {
                    CertificateSource    = certificateSource,
                    SerialNumber         = line.SerialNumber,
                    CatalogProduct       = product.CatalogProduct,
                    SupplierCode         = "34266440",
                    SupplierProducerCode = "13483667",
                    OriginFilePath       = KatrenSource.ToOriginFileName(0x1B9EFC8),
                };
                session.Save(sourceCatalog);
                certificateSource.LookupUrl = String.Format("ftp://127.0.0.1:{0}/", port);

                source.GetFilesFromSource(new CertificateTask(certificateSource, line), new List <CertificateFile>());
            }
            finally {
                if (server != null)
                {
                    server.Dispose();
                }
            }
        }
Exemple #28
0
#pragma warning restore 618

        private void UpdateInputFileProperties(PdfOperationsDesigner designer, IFunctionData data,
                                               string propertyPrefix,
                                               string filePathPropertyName,
                                               string authenticationTypePropertyName,
                                               string passwordPropertyName,
                                               string certificateSourcePropertyName,
                                               string certificateFilePathPropertyName,
                                               string certificateFilePasswordPropertyName,
                                               string certificatePropertyName)
        {
            Func <string, string> addPrefix = (value) => (string.IsNullOrEmpty(propertyPrefix)) ? value : propertyPrefix + " " + char.ToLower(value[0]) + value.Substring(1);

            designer.Properties[filePathPropertyName].Value = data.Properties[addPrefix("Pdf filename")].Value;

            AuthenticationType authenticationType = data.Properties[addPrefix("Authentication type")].GetValue <AuthenticationType>();

            designer.Properties[authenticationTypePropertyName].Value = authenticationType;
            switch (authenticationType)
            {
            case AuthenticationType.Password:
                designer.Properties[passwordPropertyName].Value = data.Properties[addPrefix("Pdf password")].Value;
                break;

            case AuthenticationType.Certificate:
                CertificateSource certificateSource = data.Properties[addPrefix("Certificate source")].GetValue <CertificateSource>();
                designer.Properties[certificateSourcePropertyName].Value = certificateSource;
                switch (certificateSource)
                {
                case CertificateSource.File:
                    designer.Properties[certificateFilePathPropertyName].Value     = data.Properties[addPrefix("Certificate file path")].Value;
                    designer.Properties[certificateFilePasswordPropertyName].Value = data.Properties[addPrefix("Certificate file password")].Value;
                    break;

                case CertificateSource.Store:
                    designer.Properties[certificatePropertyName].Value = data.Properties[addPrefix("Certificate")].Value;
                    break;
                }
                break;
            }
        }
        public void Load_certificates()
        {
            var source = new NadezhdaFarmCertificateSource();
            var line   = new DocumentLine {
                ProductEntity       = new Product(),
                CertificateFilename = "1473052_1_1.tif;1072321_1_0.tif;"
            };
            var sourceConfig = new CertificateSource {
                FtpSupplier = new Supplier {
                    Id = 1
                }
            };
            var task = new CertificateTask(sourceConfig, line);

            TestHelper.InitFiles(task.GetLocalPath(), new[] { "1473052_1_1.tif" });

            Assert.IsTrue(source.CertificateExists(line));
            var files = new List <CertificateFile>();

            source.GetFilesFromSource(task, files);
            Assert.AreEqual(1, files.Count, task.DocumentLine.CertificateError);
        }
        public virtual CertificateCatalogFile GetCatalogFile(CertificateSource source, FileCleaner cleaner)
        {
            var downloader = new FtpDownloader();
            var uri        = new Uri(source.DecodeTableUrl);

            if (uri.Scheme.Match("ftp"))
            {
                var downloadFiles = downloader.DownloadedFiles(uri,
                                                               source.LastDecodeTableDownload.HasValue ? source.LastDecodeTableDownload.Value : DateTime.MinValue,
                                                               DownHandlerPath);

                if (downloadFiles.Count > 0)
                {
                    return(new CertificateCatalogFile(source, downloadFiles[0].FileDate, downloadFiles[0].FileName));
                }
                else
                {
                    _logger.DebugFormat("Файл {0} не найден", uri);
                }
            }
            else if (uri.Scheme.Match("file"))
            {
                var src = new FileInfo(uri.LocalPath);
                if (!src.Exists)
                {
                    return(null);
                }
                //в базе даты хранятся с точнотью до секунды сравнивать их нужно так же
                if (Math.Abs((DateTime.Now - src.LastWriteTime).TotalMilliseconds) > Settings.Default.FileDownloadInterval &&
                    Math.Abs((source.LastDecodeTableDownload.GetValueOrDefault() - src.LastWriteTime).TotalSeconds) > 1)
                {
                    var dst = src.CopyTo(cleaner.TmpFile(), true);
                    return(new CertificateCatalogFile(source, src.LastWriteTime, dst.FullName));
                }
            }

            return(null);
        }
Exemple #31
0
        public void View_document_certificates()
        {
            var log      = DataMother.CreateTestDocumentLog(supplier, client);
            var document = DataMother.CreateTestDocument(supplier, client, log);
            var line     = document.Lines[0];
            //Добавим CertificateSource т.к. изменилась выборка для сертификатов - теперь необходим еще Id источника для CertificateFile
            var newCertificate = new CertificateSource {
                Supplier        = supplier,
                Name            = "Test_Source",
                SourceClassName = "Test_class_Name"
            };

            supplier.CertificateSource = newCertificate;
            session.Save(newCertificate);

            line.CatalogProduct = DataMother.Product();
            line.Product        = line.CatalogProduct.Catalog.Name;
            line.Certificate    = DataMother.Certificate(line.CatalogProduct.Catalog, newCertificate.Id.ToString());
            session.Save(line);

            var dir      = Directory.CreateDirectory(Path.Combine(DataRoot, "Certificates"));
            var filename = line.Certificate.Files[0].Filename;

            File.WriteAllText(Path.Combine(dir.FullName, filename), "");

            Open("Logs/Documents?filter.Client.Id={0}", client.Id);
            AssertText("Тестовый поставщик");
            Click("TestFile.txt");
            WaitForText("Страна");
            AssertText("Страна");
            Click(line.Product);
            WaitForText(filename);
            AssertText(filename);

            session.Delete(newCertificate);
        }