コード例 #1
0
        /// <summary>
        /// Computes the hash of a given InputStream. This is a wrapper over the HashAlgorithm crypto functions.
        /// </summary>
        /// <param name="stream">the source stream. Use a MemoryStream if uncertain.</param>
        /// <param name="hashType">the Algorithm to use to compute the hash</param>
        /// <returns>a byte[] representation of the hash. If the Stream is a null object 
        /// then null will be returned. If the Stream is empty an empty byte[] {} will be returned.</returns>
        public static byte[] ComputeHash(this Stream stream, ChecksumAlgorithm hashType = ChecksumAlgorithm.SHA256)
        {
            if (stream == null) return null;

            using (var algorithm = HashAlgorithm.Create(hashType.ToString()))
                return algorithm.ComputeHash(stream);
        }
コード例 #2
0
        public static bool TryGetChecksumAlgorithm(string checksumName, out ChecksumAlgorithm pdbChecksumAlgorithm, out int checksumSize)
        {
            switch (checksumName)
            {
            case "SHA1":
                pdbChecksumAlgorithm = ChecksumAlgorithm.SHA1;
                checksumSize         = 20;
                return(true);

            case "SHA256":
                pdbChecksumAlgorithm = ChecksumAlgorithm.SHA256;
                checksumSize         = 32;
                return(true);

            case "SHA384":
                pdbChecksumAlgorithm = ChecksumAlgorithm.SHA384;
                checksumSize         = 48;
                return(true);

            case "SHA512":
                pdbChecksumAlgorithm = ChecksumAlgorithm.SHA512;
                checksumSize         = 64;
                return(true);

            default:
                pdbChecksumAlgorithm = 0;
                checksumSize         = -1;
                return(false);
            }
        }
コード例 #3
0
ファイル: ArticleService.cs プロジェクト: Morr0/Atheer
        public async Task Update(string userId, ArticlePrimaryKey key, UpdateArticleViewModel request)
        {
            var article = await _context.Article.FirstOrDefaultAsync(x =>
                                                                     x.CreatedYear == key.CreatedYear && x.TitleShrinked == key.TitleShrinked).CAF();

            string contentChecksumPreUpdate = ChecksumAlgorithm.ComputeMD5Checksum(article.Content);

            _mapper.Map(request, article);
            _articleFactory.SetUpdated(article);

            await EnsureRequestOfNarrationIfNarratable(article, contentChecksumPreUpdate).CAF();

            await using var transaction = await _context.Database.BeginTransactionAsync().CAF();

            try
            {
                await _context.SaveChangesAsync().CAF();

                await transaction.CommitAsync().CAF();
            }
            catch (Exception e)
            {
                _logger.LogError(e.Message);
                throw new FailedOperationException();
            }
        }
コード例 #4
0
        /********EXTERNAL OBJECT PUBLIC METHODS  - END ********/

        private string CalculateCRC(byte[] input, ChecksumAlgorithm checksumAlgorithm)
        {
            CRCParameters parms = ChecksumAlgorithmUtils.getParameters(checksumAlgorithm, this.error);

            if (this.HasError())
            {
                return("");
            }
            long aux = CalculateCRC(input, parms);

            if (aux == 0 || this.HasError())
            {
                return("");
            }
            switch (parms.Width)
            {
            case 8:
                return(aux.ToString("X2"));

            case 16:
                return(aux.ToString("X4"));

            case 32:
                return(aux.ToString("X8"));

            default:
                return(aux.ToString("X"));
            }
        }
コード例 #5
0
        /// <summary>
        /// Computes the hash of a given InputStream. This is a wrapper over the HashAlgorithm crypto functions.
        /// </summary>
        /// <param name="stream">the source stream. Use a MemoryStream if uncertain.</param>
        /// <param name="hashType">the Algorithm to use to compute the hash</param>
        /// <returns>a byte[] representation of the hash. If the Stream is a null object
        /// then null will be returned. If the Stream is empty an empty byte[] {} will be returned.</returns>
        public static byte[] ComputeHash(this Stream stream, ChecksumAlgorithm hashType = ChecksumAlgorithm.SHA256)
        {
            if (stream == null)
            {
                return(null);
            }

            using (var algorithm = HashAlgorithm.Create(hashType.ToString()))
                return(algorithm.ComputeHash(stream));
        }
コード例 #6
0
        /// <summary>
        /// Computes the hash of a given InputStream. This is a wrapper over the HashAlgorithm crypto functions.
        /// </summary>
        /// <param name="stream">the source stream. Use a MemoryStream if uncertain.</param>
        /// <param name="hashType">the Algorithm to use to compute the hash</param>
        /// <returns>a byte[] representation of the hash. If the Stream is a null object 
        /// then null will be returned. If the Stream is empty an empty byte[] {} will be returned.</returns>
        public static byte[] ComputeHash(this Stream stream, ChecksumAlgorithm hashType = ChecksumAlgorithm.SHA256, long? maxBodySize = null)
        {
            if (stream == null) return null;

            using (var algorithm = HashAlgorithm.Create(hashType.ToString()))
                if (maxBodySize != null && maxBodySize > 0)
                    return algorithm.ComputeHash(stream.ReadExactly((long) maxBodySize));
                else
                    return algorithm.ComputeHash(stream);
        }
コード例 #7
0
        public static int GetHashStringSize(ChecksumAlgorithm algorithm)
        {
            var checksumComputer = GetComputer(algorithm);

            if (checksumComputer != null)
            {
                return(checksumComputer.HashSize / 4);
            }

            return(-1);
        }
コード例 #8
0
        public async Task Update(string userId, ArticlePrimaryKey key, UpdateArticleViewModel request)
        {
            var article = await(await _client.Article().FindAsync(x => x.Id == key.Id).CAF())
                          .FirstOrDefaultAsync().CAF();
            string contentChecksumPreUpdate = ChecksumAlgorithm.ComputeMD5Checksum(article.Content);

            _mapper.Map(request, article);
            _articleFactory.SetUpdated(article);

            await EnsureRequestOfNarrationIfNarratable(article, contentChecksumPreUpdate).CAF();

            await _client.Article().FindOneAndReplaceAsync(x => x.Id == key.Id, article).CAF();
        }
コード例 #9
0
        public void TestV4SignedHeadersPut(CoreChecksumAlgorithm algorithm)
        {
            var putRequest = new PutObjectRequest()
            {
                BucketName        = _bucketName,
                Key               = $"sigv4-headers-{algorithm}",
                ContentBody       = _testContent,
                ChecksumAlgorithm = ChecksumAlgorithm.FindValue(algorithm.ToString()),
                UseChunkEncoding  = false
            };

            PutAndGetChecksumTestHelper(algorithm, putRequest);
        }
コード例 #10
0
        public void TestV4aSignedTrailersPut(CoreChecksumAlgorithm algorithm)
        {
            var putRequest = new PutObjectRequest()
            {
                BucketName        = _mrapArn,
                Key               = $"sigv4a-trailers-{algorithm}",
                ContentBody       = _testContent,
                ChecksumAlgorithm = ChecksumAlgorithm.FindValue(algorithm.ToString()),
                UseChunkEncoding  = true
            };

            PutAndGetChecksumTestHelper(algorithm, putRequest);
        }
コード例 #11
0
        public static bool isHash(ChecksumAlgorithm checksumAlgorithm)
        {
            switch (checksumAlgorithm)
            {
            case ChecksumAlgorithm.MD5:
            case ChecksumAlgorithm.SHA1:
            case ChecksumAlgorithm.SHA256:
            case ChecksumAlgorithm.SHA512:
                return(true);

            default:
                return(false);
            }
        }
コード例 #12
0
        private static string GetChecksumName(ChecksumAlgorithm checksumAlgorithm)
        {
            switch (checksumAlgorithm)
            {
            case ChecksumAlgorithm.Md5:
                return(Md5AlgName);

            case ChecksumAlgorithm.Sha1:
                return(Sha1AlgName);

            default:
                throw CodeExceptions.UnexpectedArgumentValue(nameof(checksumAlgorithm), checksumAlgorithm);
            }
        }
コード例 #13
0
        public void TestV4UnsignedTrailersPut(CoreChecksumAlgorithm algorithm)
        {
            var putRequest = new PutObjectRequest()
            {
                BucketName            = _bucketName,
                Key                   = $"sigv4-unsignedcontent-trailers-{algorithm}",
                ContentBody           = _testContent,
                DisablePayloadSigning = true,
                ChecksumAlgorithm     = ChecksumAlgorithm.FindValue(algorithm.ToString()),
                UseChunkEncoding      = true
            };

            PutAndGetChecksumTestHelper(algorithm, putRequest);
        }
コード例 #14
0
        static HashAlgorithm CreateHasher(ChecksumAlgorithm checksumAlgorithm)
        {
            switch (checksumAlgorithm)
            {
            case ChecksumAlgorithm.SHA1:            return(SHA1.Create());

            case ChecksumAlgorithm.SHA256:          return(SHA256.Create());

            case ChecksumAlgorithm.SHA384:          return(SHA384.Create());

            case ChecksumAlgorithm.SHA512:          return(SHA512.Create());

            default: throw new ArgumentOutOfRangeException(nameof(checksumAlgorithm));
            }
        }
コード例 #15
0
        /// <summary>Initializes a new instance of the <see cref="SourceAnnotationInfo"/> class.</summary>
        /// <param name="path">The path to the source file.</param>
        /// <param name="methodLinesMap">Range that stores start/end lines for each method in the document.</param>
        /// <param name="sourceLanguage">Language of the source.</param>
        /// <param name="checksumAlgorithm">The checksum algorithm.</param>
        /// <param name="checksum">The checksum.</param>
        public SourceAnnotationInfo(
            string path,
            CompositeRange <int, MethodBase> methodLinesMap,
            SourceLanguage sourceLanguage,
            ChecksumAlgorithm checksumAlgorithm,
            byte[] checksum)
        {
            Code.NotNullNorEmpty(path, nameof(path));
            Code.NotNull(checksum, nameof(checksum));

            Path              = path;
            MethodLinesMap    = methodLinesMap;
            SourceLanguage    = sourceLanguage;
            ChecksumAlgorithm = checksumAlgorithm;
            Checksum          = checksum;
        }
コード例 #16
0
        public static string GetChecksumName(ChecksumAlgorithm checksumAlgorithm)
        {
            // https://github.com/dotnet/corefx/blob/master/src/System.Reflection.Metadata/specs/PE-COFF.md#pdb-checksum-debug-directory-entry-type-19
            switch (checksumAlgorithm)
            {
            case ChecksumAlgorithm.SHA1:            return("SHA1");

            case ChecksumAlgorithm.SHA256:          return("SHA256");

            case ChecksumAlgorithm.SHA384:          return("SHA384");

            case ChecksumAlgorithm.SHA512:          return("SHA512");

            default: throw new ArgumentOutOfRangeException(nameof(checksumAlgorithm));
            }
        }
コード例 #17
0
        public static string GetChecksumKey(ChecksumAlgorithm algorithm)
        {
            switch (algorithm)
            {
            case ChecksumAlgorithm.Sha1:
                return("Checksum.Sha1");

            case ChecksumAlgorithm.Sha256:
                return("Checksum.Sha256");

            case ChecksumAlgorithm.MD5:
                return("Checksum.MD5");

            default:
                return(null);
            }
        }
コード例 #18
0
        private string CalculateHash(byte[] input, ChecksumAlgorithm checksumAlgorithm)
        {
            HashUtils.HashAlgorithm alg = getHashAlgorithm(checksumAlgorithm);
            if (this.HasError())
            {
                return("");
            }
            Hashing hash = new Hashing();

            byte[] digest = hash.calculateHash(alg, input);
            if (hash.HasError())
            {
                this.error = hash.GetError();
                return("");
            }
            return(toHexaString(digest));
        }
コード例 #19
0
        /// <summary>
        /// Computes the hash of a given InputStream. This is a wrapper over the HashAlgorithm crypto functions.
        /// </summary>
        /// <param name="stream">the source stream. Use a MemoryStream if uncertain.</param>
        /// <param name="hashType">the Algorithm to use to compute the hash</param>
        /// <returns>a byte[] representation of the hash. If the Stream is a null object
        /// then null will be returned. If the Stream is empty an empty byte[] {} will be returned.</returns>
        public static byte[] ComputeHash(this Stream stream, ChecksumAlgorithm hashType = ChecksumAlgorithm.SHA256, long?maxBodySize = null)
        {
            if (stream == null)
            {
                return(null);
            }

            using (var algorithm = HashAlgorithm.Create(hashType.ToString()))
                if (maxBodySize != null && maxBodySize > 0)
                {
                    return(algorithm.ComputeHash(stream.ReadExactly((long)maxBodySize)));
                }
                else
                {
                    return(algorithm.ComputeHash(stream));
                }
        }
コード例 #20
0
        /// <summary>
        /// Creata a new checksum algorithm from an enum.
        /// </summary>
        /// <param name="hashType">The implementation to request.</param>
        /// <returns>An implementation of the algorithm.</returns>
        public static HashAlgorithm Create(ChecksumAlgorithm hashType)
        {
            switch (hashType)
            {
            case ChecksumAlgorithm.SHA256:
                return(SHA256.Create());

            case ChecksumAlgorithm.SHA1:
                return(SHA1.Create());

            case ChecksumAlgorithm.MD5:
                return(MD5.Create());

            default:
                throw new InvalidOperationException($"Invalid key hash type \"{hashType}\".");
            }
        }
コード例 #21
0
        public override unsafe bool GetDebugInfo(ChecksumAlgorithm pdbChecksumAlgorithm, ref uint pdbAge, out Guid guid, out uint stamp, out IMAGE_DEBUG_DIRECTORY pIDD, out byte[] codeViewData)
        {
            pIDD         = default;
            codeViewData = null;

            if (isDeterministic)
            {
                ((ISymUnmanagedWriter3)writer).Commit();
                var oldPos = pdbStream.Position;
                pdbStream.Position = 0;
                var checksumBytes = Hasher.Hash(pdbChecksumAlgorithm, pdbStream, pdbStream.Length);
                pdbStream.Position = oldPos;
                if (writer is ISymUnmanagedWriter8 writer8)
                {
                    RoslynContentIdProvider.GetContentId(checksumBytes, out guid, out stamp);
                    writer8.UpdateSignature(guid, stamp, pdbAge);
                    return(true);
                }
                else if (writer is ISymUnmanagedWriter7 writer7)
                {
                    fixed(byte *p = checksumBytes)
                    writer7.UpdateSignatureByHashingContent(new IntPtr(p), (uint)checksumBytes.Length);
                }
            }

            writer.GetDebugInfo(out pIDD, 0, out uint size, null);
            codeViewData = new byte[size];
            writer.GetDebugInfo(out pIDD, size, out size, codeViewData);

            if (writer is IPdbWriter comPdbWriter)
            {
                var guidBytes = new byte[16];
                Array.Copy(codeViewData, 4, guidBytes, 0, 16);
                guid = new Guid(guidBytes);
                comPdbWriter.GetSignatureAge(out stamp, out uint age);
                Debug.Assert(age == pdbAge);
                pdbAge = age;
                return(true);
            }

            Debug.Fail($"COM PDB writer doesn't impl {nameof(IPdbWriter)}");
            guid  = default;
            stamp = 0;
            return(false);
        }
コード例 #22
0
        /// <summary>Gets checksum for file if it exists.</summary>
        /// <param name="file">The file.</param>
        /// <param name="checksumAlgorithm">The checksum algorithm to use.</param>
        /// <returns>Checksum for file or empty byte array if the file does not exist.</returns>
        public static byte[] TryGetChecksum(
            string file,
            ChecksumAlgorithm checksumAlgorithm)
        {
            var algName = GetChecksumName(checksumAlgorithm);

            if (!File.Exists(file))
            {
                return(Array <byte> .Empty);
            }

            using (var f = File.OpenRead(file))
                using (var h = HashAlgorithm.Create(algName))
                {
                    // ReSharper disable once PossibleNullReferenceException
                    return(h.ComputeHash(f));
                }
        }
コード例 #23
0
        public string GenerateChecksum(string input, string inputType, string checksumAlgorithm)
        {
            ChecksumInputType chksumInputType = ChecksumInputTypeUtils.getChecksumInputType(inputType, this.error);

            byte[] inputBytes = ChecksumInputTypeUtils.getBytes(chksumInputType, input, this.error);
            if (this.HasError())
            {
                return("");
            }
            ChecksumAlgorithm algorithm = ChecksumAlgorithmUtils.getChecksumAlgorithm(checksumAlgorithm, this.error);

            if (this.HasError())
            {
                return("");
            }
            return((ChecksumAlgorithmUtils.isHash(algorithm)) ? CalculateHash(inputBytes, algorithm)
                                        : CalculateCRC(inputBytes, algorithm));
        }
コード例 #24
0
ファイル: ArticleService.cs プロジェクト: Morr0/Atheer
        private async ValueTask EnsureRequestOfNarrationIfNarratable(Article article, string contentChecksumPreUpdate)
        {
            if (!article.Narratable)
            {
                return;
            }

            string contentChecksumPostUpdate = ChecksumAlgorithm.ComputeMD5Checksum(article.Content);

            if (contentChecksumPreUpdate == contentChecksumPostUpdate)
            {
                return;
            }

            var narrationRequest = _articleFactory.CreateNarrationRequest(article, null);

            using var scope = _serviceScopeFactory.CreateScope();
            var channel = scope.ServiceProvider.GetRequiredService <Channel <ArticleNarrationRequest> >();
            await channel.Writer.WriteAsync(narrationRequest).ConfigureAwait(false);
        }
コード例 #25
0
        /// <summary>Gets checksum for resource if it exists.</summary>
        /// <param name="resourceKey">The resource key.</param>
        /// <param name="checksumAlgorithm">The checksum algorithm to use.</param>
        /// <returns>Checksum for resource or empty byte array if the resource does not exist.</returns>
        public static byte[] TryGetChecksum(
            ResourceKey resourceKey,
            ChecksumAlgorithm checksumAlgorithm)
        {
            var algName = GetChecksumName(checksumAlgorithm);

            using (var s = resourceKey.TryGetResourceStream())
            {
                if (s == null)
                {
                    return(Array <byte> .Empty);
                }

                using (var h = HashAlgorithm.Create(algName))
                {
                    // ReSharper disable once PossibleNullReferenceException
                    return(h.ComputeHash(s));
                }
            }
        }
コード例 #26
0
        public static byte[] Hash(ChecksumAlgorithm checksumAlgorithm, Stream stream, long length)
        {
            var buffer = new byte[(int)Math.Min(0x2000, length)];

            using (var hasher = CreateHasher(checksumAlgorithm)) {
                while (length > 0)
                {
                    int len  = (int)Math.Min(length, buffer.Length);
                    int read = stream.Read(buffer, 0, len);
                    if (read == 0)
                    {
                        throw new InvalidOperationException("Couldn't read all bytes");
                    }
                    hasher.TransformBlock(buffer, 0, read, buffer, 0);
                    length -= read;
                }
                hasher.TransformFinalBlock(Array2.Empty <byte>(), 0, 0);
                return(hasher.Hash);
            }
        }
コード例 #27
0
 private static Byte[] ComputeOneHundredTwentyEightBitHash(this IEnumerable <Byte> target) => target.Any() ? ChecksumAlgorithm.ComputeHash(target.ToArray()) : EmptyCollectionOneHundredTwentyEightBitHash;
コード例 #28
0
 private HashType(ChecksumAlgorithm checksum)
 {
     this.Checksum = checksum;
 }
コード例 #29
0
        public static async Task <IReadOnlyDictionary <string, string> > DigestDirectory(string root, ChecksumAlgorithm checksumAlgorithm)
        {
            var composeVisitor = new ComposeFileVisitor();

            if (Directory.Exists(root))
            {
                var dir = new DirectoryInfo(root);
                dir.WalkFileTree(composeVisitor);
            }

            var dic = new Dictionary <string, string>();

            foreach (var fileInfo in composeVisitor.Walked)
            {
                await using var stream = fileInfo.OpenRead();
                dic.Add(Path.GetRelativePath(root, fileInfo.FullName), checksumAlgorithm switch
                {
                    ChecksumAlgorithm.SHA256 => Checksum <SHA256CryptoServiceProvider>(stream),
                    ChecksumAlgorithm.MD5 => Checksum <MD5CryptoServiceProvider>(stream),
                    ChecksumAlgorithm.SHA1 => Checksum <SHA1CryptoServiceProvider>(stream),
                    _ => throw new ArgumentException(nameof(checksumAlgorithm))
                });
コード例 #30
0
 static HashAlgorithm CreateHasher(ChecksumAlgorithm checksumAlgorithm) =>
 checksumAlgorithm switch
 {
コード例 #31
0
 public Checksum(ChecksumAlgorithm algorithm, string checksum)
 {
     Algorithm     = algorithm;
     this.checksum = checksum;
 }
コード例 #32
0
 private HashUtils.HashAlgorithm getHashAlgorithm(ChecksumAlgorithm checksumAlgorithm)
 {
     return(HashAlgorithmUtils.getHashAlgorithm(ChecksumAlgorithmUtils.valueOf(checksumAlgorithm, this.error), this.error));
 }
コード例 #33
0
 private HashType(ChecksumAlgorithm checksum)
 {
     this.Checksum = checksum;
 }