Esempio n. 1
0
        public Checksum(EnableChecksum enabled = EnableChecksum.All)
        {
            _enabled = enabled;

            if (enabled.HasFlag(EnableChecksum.Adler32))
            {
                _adler32Ctx = new Adler32Context();

                _adlerPkt = new HashPacket
                {
                    Context = _adler32Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Crc16))
            {
                _crc16Ctx = new CRC16IBMContext();

                _crc16Pkt = new HashPacket
                {
                    Context = _crc16Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Crc32))
            {
                _crc32Ctx = new Crc32Context();

                _crc32Pkt = new HashPacket
                {
                    Context = _crc32Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Crc64))
            {
                _crc64Ctx = new Crc64Context();

                _crc64Pkt = new HashPacket
                {
                    Context = _crc64Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Md5))
            {
                _md5Ctx = new Md5Context();

                _md5Pkt = new HashPacket
                {
                    Context = _md5Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Sha1))
            {
                _sha1Ctx = new Sha1Context();

                _sha1Pkt = new HashPacket
                {
                    Context = _sha1Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Sha256))
            {
                _sha256Ctx = new Sha256Context();

                _sha256Pkt = new HashPacket
                {
                    Context = _sha256Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Sha384))
            {
                _sha384Ctx = new Sha384Context();

                _sha384Pkt = new HashPacket
                {
                    Context = _sha384Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Sha512))
            {
                _sha512Ctx = new Sha512Context();

                _sha512Pkt = new HashPacket
                {
                    Context = _sha512Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.SpamSum))
            {
                _ssCtx = new SpamSumContext();

                _spamsumPkt = new HashPacket
                {
                    Context = _ssCtx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher16))
            {
                _f16Ctx = new Fletcher16Context();

                _f16Pkt = new HashPacket
                {
                    Context = _f16Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher32))
            {
                _f32Ctx = new Fletcher32Context();

                _f32Pkt = new HashPacket
                {
                    Context = _f32Ctx
                };
            }

            _adlerThread   = new Thread(UpdateHash);
            _crc16Thread   = new Thread(UpdateHash);
            _crc32Thread   = new Thread(UpdateHash);
            _crc64Thread   = new Thread(UpdateHash);
            _md5Thread     = new Thread(UpdateHash);
            _sha1Thread    = new Thread(UpdateHash);
            _sha256Thread  = new Thread(UpdateHash);
            _sha384Thread  = new Thread(UpdateHash);
            _sha512Thread  = new Thread(UpdateHash);
            _spamsumThread = new Thread(UpdateHash);
            _f16Thread     = new Thread(UpdateHash);
            _f32Thread     = new Thread(UpdateHash);
        }
Esempio n. 2
0
        internal static List <ChecksumType> GetChecksums(byte[] data, EnableChecksum enabled = EnableChecksum.All)
        {
            IChecksum adler32CtxData = null;
            IChecksum crc16CtxData   = null;
            IChecksum crc32CtxData   = null;
            IChecksum crc64CtxData   = null;
            IChecksum md5CtxData     = null;

            #if !NETSTANDARD2_0
            IChecksum ripemd160CtxData = null;
            #endif
            IChecksum sha1CtxData   = null;
            IChecksum sha256CtxData = null;
            IChecksum sha384CtxData = null;
            IChecksum sha512CtxData = null;
            IChecksum ssctxData     = null;
            IChecksum f16CtxData    = null;
            IChecksum f32CtxData    = null;

            Thread adlerThreadData = new Thread(UpdateHash);
            Thread crc16ThreadData = new Thread(UpdateHash);
            Thread crc32ThreadData = new Thread(UpdateHash);
            Thread crc64ThreadData = new Thread(UpdateHash);
            Thread md5ThreadData   = new Thread(UpdateHash);
            #if !NETSTANDARD2_0
            Thread ripemd160ThreadData = new Thread(UpdateHash);
            #endif
            Thread sha1ThreadData    = new Thread(UpdateHash);
            Thread sha256ThreadData  = new Thread(UpdateHash);
            Thread sha384ThreadData  = new Thread(UpdateHash);
            Thread sha512ThreadData  = new Thread(UpdateHash);
            Thread spamsumThreadData = new Thread(UpdateHash);
            Thread f16ThreadData     = new Thread(UpdateHash);
            Thread f32ThreadData     = new Thread(UpdateHash);

            if (enabled.HasFlag(EnableChecksum.Adler32))
            {
                adler32CtxData = new Adler32Context();
                HashPacket adlerPktData = new HashPacket {
                    Context = adler32CtxData, Data = data
                };
                adlerThreadData.Start(adlerPktData);
            }

            if (enabled.HasFlag(EnableChecksum.Crc16))
            {
                crc16CtxData = new Crc16Context();
                HashPacket crc16PktData = new HashPacket {
                    Context = crc16CtxData, Data = data
                };
                crc16ThreadData.Start(crc16PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Crc32))
            {
                crc32CtxData = new Crc32Context();
                HashPacket crc32PktData = new HashPacket {
                    Context = crc32CtxData, Data = data
                };
                crc32ThreadData.Start(crc32PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Crc64))
            {
                crc64CtxData = new Crc64Context();
                HashPacket crc64PktData = new HashPacket {
                    Context = crc64CtxData, Data = data
                };
                crc64ThreadData.Start(crc64PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Md5))
            {
                md5CtxData = new Md5Context();
                HashPacket md5PktData = new HashPacket {
                    Context = md5CtxData, Data = data
                };
                md5ThreadData.Start(md5PktData);
            }

            #if !NETSTANDARD2_0
            if (enabled.HasFlag(EnableChecksum.Ripemd160))
            {
                ripemd160CtxData = new Ripemd160Context();
                HashPacket ripemd160PktData = new HashPacket {
                    Context = ripemd160CtxData, Data = data
                };
                ripemd160ThreadData.Start(ripemd160PktData);
            }
            #endif

            if (enabled.HasFlag(EnableChecksum.Sha1))
            {
                sha1CtxData = new Sha1Context();
                HashPacket sha1PktData = new HashPacket {
                    Context = sha1CtxData, Data = data
                };
                sha1ThreadData.Start(sha1PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Sha256))
            {
                sha256CtxData = new Sha256Context();
                HashPacket sha256PktData = new HashPacket {
                    Context = sha256CtxData, Data = data
                };
                sha256ThreadData.Start(sha256PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Sha384))
            {
                sha384CtxData = new Sha384Context();
                HashPacket sha384PktData = new HashPacket {
                    Context = sha384CtxData, Data = data
                };
                sha384ThreadData.Start(sha384PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Sha512))
            {
                sha512CtxData = new Sha512Context();
                HashPacket sha512PktData = new HashPacket {
                    Context = sha512CtxData, Data = data
                };
                sha512ThreadData.Start(sha512PktData);
            }

            if (enabled.HasFlag(EnableChecksum.SpamSum))
            {
                ssctxData = new SpamSumContext();
                HashPacket spamsumPktData = new HashPacket {
                    Context = ssctxData, Data = data
                };
                spamsumThreadData.Start(spamsumPktData);
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher16))
            {
                f16CtxData = new Fletcher16Context();
                HashPacket f16PktData = new HashPacket {
                    Context = f16CtxData, Data = data
                };
                f16ThreadData.Start(f16PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher32))
            {
                f32CtxData = new Fletcher32Context();
                HashPacket f32PktData = new HashPacket {
                    Context = f32CtxData, Data = data
                };
                f32ThreadData.Start(f32PktData);
            }

            while (adlerThreadData.IsAlive || crc16ThreadData.IsAlive || crc32ThreadData.IsAlive ||
                   crc64ThreadData.IsAlive || md5ThreadData.IsAlive ||
                  #if !NETSTANDARD2_0
                   ripemd160ThreadData.IsAlive ||
                  #endif
                   sha1ThreadData.IsAlive || sha256ThreadData.IsAlive || sha384ThreadData.IsAlive ||
                   sha512ThreadData.IsAlive || spamsumThreadData.IsAlive || f16ThreadData.IsAlive ||
                   f32ThreadData.IsAlive)
            {
            }

            List <ChecksumType> dataChecksums = new List <ChecksumType>();
            ChecksumType        chk;

            if (enabled.HasFlag(EnableChecksum.Adler32))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.adler32, Value = adler32CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Crc16))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.crc16, Value = crc16CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Crc32))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.crc32, Value = crc32CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Crc64))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.crc64, Value = crc64CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Md5))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.md5, Value = md5CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            #if !NETSTANDARD2_0
            if (enabled.HasFlag(EnableChecksum.Ripemd160))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.ripemd160, Value = ripemd160CtxData.End()
                };
                dataChecksums.Add(chk);
            }
            #endif

            if (enabled.HasFlag(EnableChecksum.Sha1))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.sha1, Value = sha1CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Sha256))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.sha256, Value = sha256CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Sha384))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.sha384, Value = sha384CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Sha512))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.sha512, Value = sha512CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.SpamSum))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.spamsum, Value = ssctxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher16))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.fletcher16, Value = f16CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher32))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.fletcher32, Value = f32CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            return(dataChecksums);
        }
Esempio n. 3
0
        internal static List <ChecksumType> GetChecksums(byte[] data, EnableChecksum enabled = EnableChecksum.All)
        {
            IChecksum adler32CtxData = null;
            IChecksum crc16CtxData   = null;
            IChecksum crc32CtxData   = null;
            IChecksum crc64CtxData   = null;
            IChecksum md5CtxData     = null;
            IChecksum sha1CtxData    = null;
            IChecksum sha256CtxData  = null;
            IChecksum sha384CtxData  = null;
            IChecksum sha512CtxData  = null;
            IChecksum ssctxData      = null;
            IChecksum f16CtxData     = null;
            IChecksum f32CtxData     = null;

            var adlerThreadData   = new Thread(UpdateHash);
            var crc16ThreadData   = new Thread(UpdateHash);
            var crc32ThreadData   = new Thread(UpdateHash);
            var crc64ThreadData   = new Thread(UpdateHash);
            var md5ThreadData     = new Thread(UpdateHash);
            var sha1ThreadData    = new Thread(UpdateHash);
            var sha256ThreadData  = new Thread(UpdateHash);
            var sha384ThreadData  = new Thread(UpdateHash);
            var sha512ThreadData  = new Thread(UpdateHash);
            var spamsumThreadData = new Thread(UpdateHash);
            var f16ThreadData     = new Thread(UpdateHash);
            var f32ThreadData     = new Thread(UpdateHash);

            if (enabled.HasFlag(EnableChecksum.Adler32))
            {
                adler32CtxData = new Adler32Context();

                var adlerPktData = new HashPacket
                {
                    Context = adler32CtxData,
                    Data    = data
                };

                adlerThreadData.Start(adlerPktData);
            }

            if (enabled.HasFlag(EnableChecksum.Crc16))
            {
                crc16CtxData = new CRC16IBMContext();

                var crc16PktData = new HashPacket
                {
                    Context = crc16CtxData,
                    Data    = data
                };

                crc16ThreadData.Start(crc16PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Crc32))
            {
                crc32CtxData = new Crc32Context();

                var crc32PktData = new HashPacket
                {
                    Context = crc32CtxData,
                    Data    = data
                };

                crc32ThreadData.Start(crc32PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Crc64))
            {
                crc64CtxData = new Crc64Context();

                var crc64PktData = new HashPacket
                {
                    Context = crc64CtxData,
                    Data    = data
                };

                crc64ThreadData.Start(crc64PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Md5))
            {
                md5CtxData = new Md5Context();

                var md5PktData = new HashPacket
                {
                    Context = md5CtxData,
                    Data    = data
                };

                md5ThreadData.Start(md5PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Sha1))
            {
                sha1CtxData = new Sha1Context();

                var sha1PktData = new HashPacket
                {
                    Context = sha1CtxData,
                    Data    = data
                };

                sha1ThreadData.Start(sha1PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Sha256))
            {
                sha256CtxData = new Sha256Context();

                var sha256PktData = new HashPacket
                {
                    Context = sha256CtxData,
                    Data    = data
                };

                sha256ThreadData.Start(sha256PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Sha384))
            {
                sha384CtxData = new Sha384Context();

                var sha384PktData = new HashPacket
                {
                    Context = sha384CtxData,
                    Data    = data
                };

                sha384ThreadData.Start(sha384PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Sha512))
            {
                sha512CtxData = new Sha512Context();

                var sha512PktData = new HashPacket
                {
                    Context = sha512CtxData,
                    Data    = data
                };

                sha512ThreadData.Start(sha512PktData);
            }

            if (enabled.HasFlag(EnableChecksum.SpamSum))
            {
                ssctxData = new SpamSumContext();

                var spamsumPktData = new HashPacket
                {
                    Context = ssctxData,
                    Data    = data
                };

                spamsumThreadData.Start(spamsumPktData);
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher16))
            {
                f16CtxData = new Fletcher16Context();

                var f16PktData = new HashPacket
                {
                    Context = f16CtxData,
                    Data    = data
                };

                f16ThreadData.Start(f16PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher32))
            {
                f32CtxData = new Fletcher32Context();

                var f32PktData = new HashPacket
                {
                    Context = f32CtxData,
                    Data    = data
                };

                f32ThreadData.Start(f32PktData);
            }

            while (adlerThreadData.IsAlive ||
                   crc16ThreadData.IsAlive ||
                   crc32ThreadData.IsAlive ||
                   crc64ThreadData.IsAlive ||
                   md5ThreadData.IsAlive ||
                   sha1ThreadData.IsAlive ||
                   sha256ThreadData.IsAlive ||
                   sha384ThreadData.IsAlive ||
                   sha512ThreadData.IsAlive ||
                   spamsumThreadData.IsAlive ||
                   f16ThreadData.IsAlive ||
                   f32ThreadData.IsAlive)
            {
            }

            List <ChecksumType> dataChecksums = new List <ChecksumType>();
            ChecksumType        chk;

            if (enabled.HasFlag(EnableChecksum.Adler32))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.adler32,
                    Value = adler32CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Crc16))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.crc16,
                    Value = crc16CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Crc32))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.crc32,
                    Value = crc32CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Crc64))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.crc64,
                    Value = crc64CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Md5))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.md5,
                    Value = md5CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Sha1))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.sha1,
                    Value = sha1CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Sha256))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.sha256,
                    Value = sha256CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Sha384))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.sha384,
                    Value = sha384CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Sha512))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.sha512,
                    Value = sha512CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.SpamSum))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.spamsum,
                    Value = ssctxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher16))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.fletcher16,
                    Value = f16CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher32))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.fletcher32,
                    Value = f32CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            return(dataChecksums);
        }
Esempio n. 4
0
        public Checksum(EnableChecksum enabled = EnableChecksum.All)
        {
            this.enabled = enabled;

            if (enabled.HasFlag(EnableChecksum.Adler32))
            {
                adler32Ctx = new Adler32Context();
                adlerPkt   = new HashPacket {
                    Context = adler32Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Crc16))
            {
                crc16Ctx = new Crc16Context();
                crc16Pkt = new HashPacket {
                    Context = crc16Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Crc32))
            {
                crc32Ctx = new Crc32Context();
                crc32Pkt = new HashPacket {
                    Context = crc32Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Crc64))
            {
                crc64Ctx = new Crc64Context();
                crc64Pkt = new HashPacket {
                    Context = crc64Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Md5))
            {
                md5Ctx = new Md5Context();
                md5Pkt = new HashPacket {
                    Context = md5Ctx
                };
            }

            #if !NETSTANDARD2_0
            if (enabled.HasFlag(EnableChecksum.Ripemd160))
            {
                ripemd160Ctx = new Ripemd160Context();
                ripemd160Pkt = new HashPacket {
                    Context = ripemd160Ctx
                };
            }
            #endif

            if (enabled.HasFlag(EnableChecksum.Sha1))
            {
                sha1Ctx = new Sha1Context();
                sha1Pkt = new HashPacket {
                    Context = sha1Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Sha256))
            {
                sha256Ctx = new Sha256Context();
                sha256Pkt = new HashPacket {
                    Context = sha256Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Sha384))
            {
                sha384Ctx = new Sha384Context();
                sha384Pkt = new HashPacket {
                    Context = sha384Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Sha512))
            {
                sha512Ctx = new Sha512Context();
                sha512Pkt = new HashPacket {
                    Context = sha512Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.SpamSum))
            {
                ssctx      = new SpamSumContext();
                spamsumPkt = new HashPacket {
                    Context = ssctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher16))
            {
                f16Ctx = new Fletcher16Context();
                f16Pkt = new HashPacket {
                    Context = f16Ctx
                };
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher32))
            {
                f32Ctx = new Fletcher32Context();
                f32Pkt = new HashPacket {
                    Context = f32Ctx
                };
            }

            adlerThread = new Thread(UpdateHash);
            crc16Thread = new Thread(UpdateHash);
            crc32Thread = new Thread(UpdateHash);
            crc64Thread = new Thread(UpdateHash);
            md5Thread   = new Thread(UpdateHash);
            #if !NETSTANDARD2_0
            ripemd160Thread = new Thread(UpdateHash);
            #endif
            sha1Thread    = new Thread(UpdateHash);
            sha256Thread  = new Thread(UpdateHash);
            sha384Thread  = new Thread(UpdateHash);
            sha512Thread  = new Thread(UpdateHash);
            spamsumThread = new Thread(UpdateHash);
            f16Thread     = new Thread(UpdateHash);
            f32Thread     = new Thread(UpdateHash);
        }