Esempio n. 1
0
        /// <summary>Initializes a new instance of the CRC class.</summary>
        /// <param name="parameters">The parameters to utilize in the CRC calculation.</param>
        /// <exception cref="ArgumentNullException">When the specified parameters are null.</exception>
        public Crc(CrcParameters parameters) : base()
        {
            lock (syncLock) {
                if (parameters == null)
                {
                    throw new ArgumentNullException("parameters", Hasher.Properties.Resources.paramCantBeNull);
                }
                this.parameters = parameters;
                HashSizeValue   = this.parameters.Order;

                Crc.BuildLookup(this.parameters);
                lookup = (long[])lookupTables[this.parameters];
                if (this.parameters.Order == 64)
                {
                    registerMask = 0x00FFFFFFFFFFFFFF;
                }
                else
                {
                    registerMask = (long)(Math.Pow(2, (this.parameters.Order - 8)) - 1);
                }

                checksum = this.parameters.InitialValue;
                if (this.parameters.ReflectInput)
                {
                    checksum = Reflect(checksum, this.parameters.Order);
                }
            }
        }
Esempio n. 2
0
 /// <summary>Initializes a new instance of the XUM32 class.</summary>
 public Xum32() : base()
 {
     lock (syncLock) {
         HashSizeValue = 32;
         crcHash       = new Crc(CrcParameters.GetParameters(CrcStandard.Crc32Bit));
         elfHash       = new ElfHash();
     }
 }
Esempio n. 3
0
        /// <summary>Build the CRC lookup table for a given polynomial.</summary>
        static private void BuildLookup(CrcParameters param)
        {
            if (lookupTables.Contains(param))
            {
                // No sense in creating the table twice.
                return;
            }

            long[] table     = new long[256];
            long   topBit    = (long)1 << (param.Order - 1);
            long   widthMask = (((1 << (param.Order - 1)) - 1) << 1) | 1;

            // Build the table.
            for (int i = 0; i < table.Length; i++)
            {
                table[i] = i;

                if (param.ReflectInput)
                {
                    table[i] = Reflect((long)i, 8);
                }

                table[i] = table[i] << (param.Order - 8);

                for (int j = 0; j < 8; j++)
                {
                    if ((table[i] & topBit) != 0)
                    {
                        table[i] = (table[i] << 1) ^ param.Polynomial;
                    }
                    else
                    {
                        table[i] <<= 1;
                    }
                }

                if (param.ReflectInput)
                {
                    table[i] = Reflect(table[i], param.Order);
                }

                table[i] &= widthMask;
            }

            // Add the new lookup table.
            lookupTables.Add(param, table);
        }
        /// <summary>Retrieves a standard set of CRC parameters.</summary>
        /// <param name="standard">The name of the standard parameter set to retrieve.</param>
        /// <returns>The CRC Parameters for the given standard.</returns>
        public static CrcParameters GetParameters(CrcStandard standard)
        {
            CrcParameters param = null;

            switch (standard)
            {
            case CrcStandard.Crc8Bit: param = new CrcParameters(8, 0x07, 0, 0, false); break;

            case CrcStandard.Crc8BitIcode: param = new CrcParameters(8, 0x1D, 0xFD, 0, false); break;

            case CrcStandard.Crc8BitItu: param = new CrcParameters(8, 0x07, 0, 0x55, false); break;

            case CrcStandard.Crc8BitMaxim: param = new CrcParameters(8, 0x31, 0, 0, true); break;

            case CrcStandard.Crc8BitWcdma: param = new CrcParameters(8, 0x9B, 0, 0, true); break;

            case CrcStandard.Crc16Bit: param = new CrcParameters(16, 0x8005, 0, 0, true); break;

            case CrcStandard.Crc16BitArc: goto case CrcStandard.Crc16Bit;

            case CrcStandard.Crc16BitIbm: goto case CrcStandard.Crc16Bit;

            case CrcStandard.Crc16BitLha: goto case CrcStandard.Crc16Bit;

            case CrcStandard.Crc16BitCcitt: param = new CrcParameters(16, 0x1021, 0, 0, true); break;

            case CrcStandard.Crc16BitKermit: goto case CrcStandard.Crc16BitCcitt;

            case CrcStandard.Crc16BitCcittFalse: param = new CrcParameters(16, 0x1021, 0xFFFF, 0, false); break;

            case CrcStandard.Crc16BitMaxim: param = new CrcParameters(16, 0x8005, 0, 0xFFFF, true); break;

            case CrcStandard.Crc16BitUsb: param = new CrcParameters(16, 0x8005, 0xFFFF, 0xFFFF, true); break;

            case CrcStandard.Crc16BitX25: param = new CrcParameters(16, 0x1021, 0xFFFF, 0xFFFF, true); break;

            case CrcStandard.Crc16BitXmodem: param = new CrcParameters(16, 0x1021, 0, 0, false); break;

            case CrcStandard.Crc16BitZmodem: goto case CrcStandard.Crc16BitXmodem;

            case CrcStandard.Crc16BitXkermit: param = new CrcParameters(16, 0x8408, 0, 0, true); break;

            case CrcStandard.Crc24Bit: param = new CrcParameters(24, 0x864CFB, 0xB704CE, 0, false); break;

            case CrcStandard.Crc24BitOpenPgp: goto case CrcStandard.Crc24Bit;

            case CrcStandard.Crc32Bit: param = new CrcParameters(32, 0x04C11DB7, 0xFFFFFFFF, 0xFFFFFFFF, true); break;

            case CrcStandard.Crc32BitPkzip: goto case CrcStandard.Crc32Bit;

            case CrcStandard.Crc32BitItu: goto case CrcStandard.Crc32Bit;

            case CrcStandard.Crc32BitBzip2: param = new CrcParameters(32, 0x04C11DB7, 0xFFFFFFFF, 0xFFFFFFFF, false); break;

            case CrcStandard.Crc32BitIscsi: param = new CrcParameters(32, 0x1EDC6F41, 0xFFFFFFFF, 0xFFFFFFFF, true); break;

            case CrcStandard.Crc32BitJam: param = new CrcParameters(32, 0x04C11DB7, 0xFFFFFFFF, 0, true); break;

            case CrcStandard.Crc32BitPosix: param = new CrcParameters(32, 0x04C11DB7, 0, 0xFFFFFFFF, false); break;

            case CrcStandard.Crc32BitCksum: goto case CrcStandard.Crc32BitPosix;

            case CrcStandard.Crc32BitMpeg2: param = new CrcParameters(32, 0x04C11DB7, 0xFFFFFFFF, 0, false); break;

            case CrcStandard.Crc64Bit: param = new CrcParameters(64, 0x42F0E1EBA9EA3693, 0, 0, false); break;

            case CrcStandard.Crc64BitWE: param = new CrcParameters(64, (long)0x42F0E1EBA9EA3693, -1, -1, false); break;

            case CrcStandard.Crc64BitIso: param = new CrcParameters(64, 0x000000000000001B, 0, 0, true); break;

            case CrcStandard.Crc64BitJones: param = new CrcParameters(64, unchecked ((long)0xAD93D23594C935A9), 0, 0, true); break;
            }

            return(param);
        }
Esempio n. 5
0
		/// <summary>Initializes a new instance of the Cksum class.</summary>
		public Cksum() : base(CrcParameters.GetParameters(CrcStandard.Crc32BitCksum)) { }
Esempio n. 6
0
 // Pre-build the more popular lookup tables.
 static Crc()
 {
     lookupTables = new Hashtable();
     BuildLookup(CrcParameters.GetParameters(CrcStandard.Crc32Bit));
 }
Esempio n. 7
0
 /// <summary>Initializes a new instance of the CRC class.</summary>
 /// <remarks>This constructor implements the default parameters of Crc32Bit.</remarks>
 public Crc() : this(CrcParameters.GetParameters(CrcStandard.Crc32Bit))
 {
 }
Esempio n. 8
0
 // Pre-build the more popular lookup tables.
 static Crc()
 {
     lookupTables = new Dictionary <CrcParameters, long[]>();
     BuildLookup(CrcParameters.GetParameters(CrcStandard.Crc32Bit));
 }