Exemple #1
0
        /// <summary>
        /// Applies hashing on string value
        /// </summary>
        /// <param name="input">string that is going to be hashed</param>
        /// <returns>new string containing hashed content</returns>
        protected void HashString(ref string input, DataCategory?dataCategory)
        {
            string hashedValue;

            if (dataCategory.HasValue && dataCategory.Value == DataCategory.POD)
            {
                if (Messlokation.ValidateId(input) || input.Length == 33)
                {
                    string base36String = Sha256Hash(input, BASE36_ALPHABET);
                    hashedValue = $"{HASHED_MESSLOKATION_PREFIX}{base36String.Substring(0, 31)}";
                    Debug.Assert(Messlokation.ValidateId(hashedValue));
                }
                else if (Marktlokation.ValidateId(input) || input.Length == 11)
                {
                    string base10String = Sha256Hash(input, BASE10_ALPHABET);
                    base10String = $"{HASHED_MARKTLOKATION_PREFIX}{base10String.Substring(0, 9)}";
                    string checkSum = Marktlokation.GetChecksum(base10String);
                    hashedValue = base10String + checkSum;
                    Debug.Assert(Marktlokation.ValidateId(hashedValue));
                }
                else
                {
                    hashedValue = Sha256Hash(input);
                }
            }
            else
            {
                hashedValue = Sha256Hash(input);
            }
            input = hashedValue;
        }
Exemple #2
0
 /// <summary>
 /// Checks if a stright might originate from <see cref="AnonymizerApproach.HASH"/>
 /// </summary>
 /// <param name="key">a string, e.g. '54321012345'</param>
 /// <returns>true if the <paramref name="key"/> could originate from hashing.</returns>
 public static bool IsHashedKey(string key)
 {
     if (string.IsNullOrWhiteSpace(key))
     {
         return(false);
     }
     if ((Marktlokation.ValidateId(key) && key.StartsWith(HASHED_MARKTLOKATION_PREFIX)) ||
         (Messlokation.ValidateId(key) && key.StartsWith(HASHED_MESSLOKATION_PREFIX)))
     {
         return(true);
     }
     else
     {
         byte[] bytes;
         try
         {
             bytes = Convert.FromBase64String(key);
         }
         catch (FormatException)
         {
             return(false);
         }
         return(true); // Todo: fix this
                       //return bytes.Length == 256 / 8; // sha256 = 256 bits
     }
 }
Exemple #3
0
 public void TestMaLoIdValidity()
 {
     Assert.IsFalse(Marktlokation.ValidateId(null));
     Assert.IsFalse(Marktlokation.ValidateId(" "));
     Assert.IsTrue(Marktlokation.ValidateId("51238696781"));
     Assert.IsTrue(Marktlokation.ValidateId("41373559241"));
     Assert.IsTrue(Marktlokation.ValidateId("56789012345"));
     Assert.IsTrue(Marktlokation.ValidateId("52935155442"));
     Assert.IsFalse(Marktlokation.ValidateId("512386967890"));
     Assert.IsFalse(Marktlokation.ValidateId("41373559240"));
     Assert.IsFalse(Marktlokation.ValidateId("12345"));
     Assert.IsFalse(Marktlokation.ValidateId("asdFG"));
     Assert.IsFalse(Marktlokation.ValidateId("DE1234567890123456789012345678901"));
 }
Exemple #4
0
        public void TestCompletenessReportHashing()
        {
            BO4E.StaticLogger.Logger = new Microsoft.Extensions.Logging.Debug.DebugLogger("Testlogger", (log, level) => { return(true); });
            CompletenessReport cr = new CompletenessReport()
            {
                LokationsId = "56789012345",
                Coverage    = 0.9M,
                Einheit     = BO4E.ENUM.Mengeneinheit.MWH,
                wertermittlungsverfahren = BO4E.ENUM.Wertermittlungsverfahren.MESSUNG,
                UserProperties           = new Dictionary <string, JToken>()
                {
                    { "anlage", "5012345678" },
                    { "profil", "123456" }
                }
            };

            Assert.IsTrue(cr.IsValid());
            var conf = new AnonymizerConfiguration();

            conf.SetOption(DataCategory.POD, AnonymizerApproach.HASH);
            conf.SetOption(DataCategory.USER_PROPERTIES, AnonymizerApproach.HASH);
            CompletenessReport hashedReport;

            using (Anonymizer anonymizer = new Anonymizer(conf))
            {
                hashedReport = anonymizer.ApplyOperations <CompletenessReport>(cr);
            }
            Assert.IsNotNull(hashedReport);
            Assert.AreNotEqual(cr.LokationsId, hashedReport.LokationsId);
            Assert.IsTrue(Marktlokation.ValidateId(hashedReport.LokationsId));
            Assert.IsNotNull(cr.UserProperties["anlage"]);
            Assert.AreNotEqual(cr.UserProperties["anlage"].Value <string>(), hashedReport.UserProperties["anlage"].Value <string>());
            Assert.IsNotNull(cr.UserProperties["profil"]);
            Assert.AreNotEqual(cr.UserProperties["profil"].Value <string>(), hashedReport.UserProperties["profil"].Value <string>());

            conf.hashingSalt = "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=";
            CompletenessReport saltedReport;

            using (Anonymizer anonymizer = new Anonymizer(conf))
            {
                saltedReport = anonymizer.ApplyOperations <CompletenessReport>(cr);
            }
            Assert.IsNotNull(saltedReport.LokationsId);
            Assert.AreNotEqual(cr.LokationsId, saltedReport.LokationsId);
            Assert.AreNotEqual(hashedReport.LokationsId, saltedReport.LokationsId);

            Assert.IsTrue(Anonymizer.IsHashedKey(hashedReport.LokationsId));
            Assert.IsTrue(Anonymizer.IsHashedKey(saltedReport.LokationsId));
        }
        /// <summary>
        ///     Convert CompletenessReport to CSV string
        /// </summary>
        /// <param name="separator">Seperatur char for CSV items. By default is ';'</param>
        /// <param name="headerLine">Shows header of columns in return string?</param>
        /// <param name="lineTerminator">This value goes to end of every line. By default is "\\n"</param>
        /// <returns></returns>
        public string ToCSV(string separator = ";", bool headerLine = true, string lineTerminator = "\\n")
        {
            var builder = new StringBuilder();

            if (headerLine)
            {
                var headerColumns = new List <string>
                {
                    "Startdatum",
                    "Enddatum",
                    "MeLo",
                    "MaLo",
                    "Messung",
                    "MSB",
                    "Profil-Nr.",
                    "Profil-Typ",
                    "Zeitbereich in dem kein wahrer Wert vorhanden ist von",
                    "Zeitbereich in dem kein wahrer Wert vorhanden ist bis",
                    "Anzahl fehlende Werte",
                    "Prozentuale Vollständigkeit",
                    "Status"
                };
                builder.Append(string.Join(separator, headerColumns) + lineTerminator);
            }

            var columns = new List <string>
            {
                ReferenceTimeFrame.Startdatum.Value.ToString("yyyy-MM-ddTHH:mm:ssZ"),
                ReferenceTimeFrame.Enddatum.Value.ToString("yyyy-MM-ddTHH:mm:ssZ")
            };

            if (Messlokation.ValidateId(LokationsId))
            {
                columns.Add(LokationsId);  // melo
                columns.Add(string.Empty); // malo
            }
            else if (Marktlokation.ValidateId(LokationsId))
            {
                columns.Add(string.Empty); //melo
                columns.Add(LokationsId);  //malo
            }
            else
            {
                // fallback only
                columns.Add(LokationsId);
                columns.Add(LokationsId);
            }

            columns.Add(imsysRegex.Match(Obiskennzahl).Success ? "IMS" : "RLM"); // messung
            columns.Add("MSB");                                                  // MSB

            if (UserProperties.TryGetValue("profil", out var profil))
            {
                columns.Add(profil.ToString());
            }
            else
            {
                columns.Add(string.Empty);
            }

            if (UserProperties.TryGetValue("profilRolle", out var profilRolle))
            {
                columns.Add(profilRolle.ToString());
            }
            else
            {
                columns.Add(string.Empty);
            }
            if (Gaps != null && Gaps.Any())
            {
                var minGap = Gaps.Min(x => x.Startdatum); // OrderBy(x => x.Startdatum).First().Startdatum;
                var maxGap = Gaps.Max(x => x.Enddatum);   // OrderByDescending(x => x.Enddatum).First().Enddatum;
                columns.Add(minGap.ToString("yyyy-MM-ddTHH:mm:ssZ"));
                columns.Add(maxGap.ToString("yyyy-MM-ddTHH:mm:ssZ"));
                var gapsHours = (maxGap - minGap).TotalHours;
                columns.Add((gapsHours * 4).ToString(CultureInfo.InvariantCulture));
            }
            else
            {
                columns.Add(string.Empty);
                columns.Add(string.Empty);
                columns.Add(string.Empty);
            }

            if (Coverage.HasValue)
            {
                columns.Add((Coverage.Value * 100).ToString("0.####") + " %");
            }
            else
            {
                columns.Add(string.Empty);
            }
            columns.Add("Status");
            builder.Append(string.Join(separator, columns) + lineTerminator);

            return(builder.ToString());
        }