aaru-dps/Aaru
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.git synced 2025-12-16 19:24:25 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
4c2098410e79cb831ff81ce9069531144c921ff2
Aaru/Aaru.Core/Checksum.cs

806 lines
23 KiB
C#
Raw Blame History

// /***************************************************************************
// Aaru Data Preservation Suite
// ----------------------------------------------------------------------------
//
// Filename : Checksum.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Core algorithms.
//
// --[ Description ] ----------------------------------------------------------
//
// Multithread checksumming and hashing.
//
// --[ License ] --------------------------------------------------------------
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2025 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
using System.Threading;
using Aaru.Checksums;
using Aaru.CommonTypes.AaruMetadata;
using Aaru.CommonTypes.Interfaces;
namespace Aaru.Core;
/// <summary>Enabled checksums</summary>
[Flags]
public enum EnableChecksum
{
/// <summary>Enables Adler-32</summary>
Adler32 = 1,
/// <summary>Enables CRC-16</summary>
Crc16 = 2,
/// <summary>Enables CRC-32</summary>
Crc32 = 4,
/// <summary>Enables CRC-64</summary>
Crc64 = 8,
/// <summary>Enables MD5</summary>
Md5 = 16,
/// <summary>Enables SHA1</summary>
Sha1 = 64,
/// <summary>Enables SHA2-256</summary>
Sha256 = 128,
/// <summary>Enables SHA2-384</summary>
Sha384 = 256,
/// <summary>Enables SHA2-512</summary>
Sha512 = 512,
/// <summary>Enables SpamSum</summary>
SpamSum = 1024,
/// <summary>Enables Fletcher-16</summary>
Fletcher16 = 2048,
/// <summary>Enables Fletcher-32</summary>
Fletcher32 = 4096,
/// <summary>Enables all known checksums</summary>
All = Adler32 | Crc16 | Crc32 | Crc64 | Md5 | Sha1 | Sha256 | Sha384 | Sha512 | SpamSum | Fletcher16 | Fletcher32
}
/// <summary>Checksums and hashes data, with different algorithms, multithreaded</summary>
public sealed class Checksum
{
readonly IChecksum _adler32Ctx;
readonly IChecksum _crc16Ctx;
readonly IChecksum _crc32Ctx;
readonly IChecksum _crc64Ctx;
readonly EnableChecksum _enabled;
readonly IChecksum _f16Ctx;
readonly IChecksum _f32Ctx;
readonly IChecksum _md5Ctx;
readonly IChecksum _sha1Ctx;
readonly IChecksum _sha256Ctx;
readonly IChecksum _sha384Ctx;
readonly IChecksum _sha512Ctx;
readonly IChecksum _ssCtx;
HashPacket _adlerPkt;
Thread _adlerThread;
HashPacket _crc16Pkt;
Thread _crc16Thread;
HashPacket _crc32Pkt;
Thread _crc32Thread;
HashPacket _crc64Pkt;
Thread _crc64Thread;
HashPacket _f16Pkt;
Thread _f16Thread;
HashPacket _f32Pkt;
Thread _f32Thread;
HashPacket _md5Pkt;
Thread _md5Thread;
HashPacket _sha1Pkt;
Thread _sha1Thread;
HashPacket _sha256Pkt;
Thread _sha256Thread;
HashPacket _sha384Pkt;
Thread _sha384Thread;
HashPacket _sha512Pkt;
Thread _sha512Thread;
HashPacket _spamsumPkt;
Thread _spamsumThread;
/// <summary>Initializes an instance of the checksum operations</summary>
/// <param name="enabled">Enabled checksums</param>
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);
}
/// <summary>Updates the checksum with new data</summary>
/// <param name="data">New data</param>
public void Update(byte[] data)
{
if(_enabled.HasFlag(EnableChecksum.Adler32))
{
_adlerPkt.Data = data;
_adlerThread.Start(_adlerPkt);
}
if(_enabled.HasFlag(EnableChecksum.Crc16))
{
_crc16Pkt.Data = data;
_crc16Thread.Start(_crc16Pkt);
}
if(_enabled.HasFlag(EnableChecksum.Crc32))
{
_crc32Pkt.Data = data;
_crc32Thread.Start(_crc32Pkt);
}
if(_enabled.HasFlag(EnableChecksum.Crc64))
{
_crc64Pkt.Data = data;
_crc64Thread.Start(_crc64Pkt);
}
if(_enabled.HasFlag(EnableChecksum.Md5))
{
_md5Pkt.Data = data;
_md5Thread.Start(_md5Pkt);
}
if(_enabled.HasFlag(EnableChecksum.Sha1))
{
_sha1Pkt.Data = data;
_sha1Thread.Start(_sha1Pkt);
}
if(_enabled.HasFlag(EnableChecksum.Sha256))
{
_sha256Pkt.Data = data;
_sha256Thread.Start(_sha256Pkt);
}
if(_enabled.HasFlag(EnableChecksum.Sha384))
{
_sha384Pkt.Data = data;
_sha384Thread.Start(_sha384Pkt);
}
if(_enabled.HasFlag(EnableChecksum.Sha512))
{
_sha512Pkt.Data = data;
_sha512Thread.Start(_sha512Pkt);
}
if(_enabled.HasFlag(EnableChecksum.SpamSum))
{
_spamsumPkt.Data = data;
_spamsumThread.Start(_spamsumPkt);
}
if(_enabled.HasFlag(EnableChecksum.Fletcher16))
{
_f16Pkt.Data = data;
_f16Thread.Start(_f16Pkt);
}
if(_enabled.HasFlag(EnableChecksum.Fletcher32))
{
_f32Pkt.Data = data;
_f32Thread.Start(_f32Pkt);
}
while(_adlerThread.IsAlive ||
_crc16Thread.IsAlive ||
_crc32Thread.IsAlive ||
_crc64Thread.IsAlive ||
_md5Thread.IsAlive ||
_sha1Thread.IsAlive ||
_sha256Thread.IsAlive ||
_sha384Thread.IsAlive ||
_sha512Thread.IsAlive ||
_spamsumThread.IsAlive ||
_f16Thread.IsAlive ||
_f32Thread.IsAlive) {}
if(_enabled.HasFlag(EnableChecksum.Adler32)) _adlerThread = new Thread(UpdateHash);
if(_enabled.HasFlag(EnableChecksum.Crc16)) _crc16Thread = new Thread(UpdateHash);
if(_enabled.HasFlag(EnableChecksum.Crc32)) _crc32Thread = new Thread(UpdateHash);
if(_enabled.HasFlag(EnableChecksum.Crc16)) _crc64Thread = new Thread(UpdateHash);
if(_enabled.HasFlag(EnableChecksum.Md5)) _md5Thread = new Thread(UpdateHash);
if(_enabled.HasFlag(EnableChecksum.Sha1)) _sha1Thread = new Thread(UpdateHash);
if(_enabled.HasFlag(EnableChecksum.Sha256)) _sha256Thread = new Thread(UpdateHash);
if(_enabled.HasFlag(EnableChecksum.Sha384)) _sha384Thread = new Thread(UpdateHash);
if(_enabled.HasFlag(EnableChecksum.Sha512)) _sha512Thread = new Thread(UpdateHash);
if(_enabled.HasFlag(EnableChecksum.SpamSum)) _spamsumThread = new Thread(UpdateHash);
if(_enabled.HasFlag(EnableChecksum.Fletcher16)) _f16Thread = new Thread(UpdateHash);
if(_enabled.HasFlag(EnableChecksum.Fletcher32)) _f32Thread = new Thread(UpdateHash);
}
/// <summary>Finishes the checksums</summary>
/// <returns>Returns the checksum results</returns>
public List<CommonTypes.AaruMetadata.Checksum> End()
{
List<CommonTypes.AaruMetadata.Checksum> chks = [];
if(_enabled.HasFlag(EnableChecksum.Adler32))
{
chks.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.Adler32,
Value = _adler32Ctx.End()
});
}
if(_enabled.HasFlag(EnableChecksum.Crc16))
{
chks.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.CRC16,
Value = _crc16Ctx.End()
});
}
if(_enabled.HasFlag(EnableChecksum.Crc32))
{
chks.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.CRC32,
Value = _crc32Ctx.End()
});
}
if(_enabled.HasFlag(EnableChecksum.Crc64))
{
chks.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.CRC64,
Value = _crc64Ctx.End()
});
}
if(_enabled.HasFlag(EnableChecksum.Md5))
{
chks.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.Md5,
Value = _md5Ctx.End()
});
}
if(_enabled.HasFlag(EnableChecksum.Sha1))
{
chks.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.Sha1,
Value = _sha1Ctx.End()
});
}
if(_enabled.HasFlag(EnableChecksum.Sha256))
{
chks.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.Sha256,
Value = _sha256Ctx.End()
});
}
if(_enabled.HasFlag(EnableChecksum.Sha384))
{
chks.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.Sha384,
Value = _sha384Ctx.End()
});
}
if(_enabled.HasFlag(EnableChecksum.Sha512))
{
chks.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.Sha512,
Value = _sha512Ctx.End()
});
}
if(_enabled.HasFlag(EnableChecksum.SpamSum))
{
chks.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.SpamSum,
Value = _ssCtx.End()
});
}
if(_enabled.HasFlag(EnableChecksum.Fletcher16))
{
chks.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.Fletcher16,
Value = _f16Ctx.End()
});
}
if(!_enabled.HasFlag(EnableChecksum.Fletcher32)) return chks;
chks.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.Fletcher32,
Value = _f32Ctx.End()
});
return chks;
}
internal static List<CommonTypes.AaruMetadata.Checksum> 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<CommonTypes.AaruMetadata.Checksum> dataChecksums = [];
if(enabled.HasFlag(EnableChecksum.Adler32))
{
dataChecksums.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.Adler32,
Value = adler32CtxData.End()
});
}
if(enabled.HasFlag(EnableChecksum.Crc16))
{
dataChecksums.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.CRC16,
Value = crc16CtxData.End()
});
}
if(enabled.HasFlag(EnableChecksum.Crc32))
{
dataChecksums.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.CRC32,
Value = crc32CtxData.End()
});
}
if(enabled.HasFlag(EnableChecksum.Crc64))
{
dataChecksums.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.CRC64,
Value = crc64CtxData.End()
});
}
if(enabled.HasFlag(EnableChecksum.Md5))
{
dataChecksums.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.Md5,
Value = md5CtxData.End()
});
}
if(enabled.HasFlag(EnableChecksum.Sha1))
{
dataChecksums.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.Sha1,
Value = sha1CtxData.End()
});
}
if(enabled.HasFlag(EnableChecksum.Sha256))
{
dataChecksums.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.Sha256,
Value = sha256CtxData.End()
});
}
if(enabled.HasFlag(EnableChecksum.Sha384))
{
dataChecksums.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.Sha384,
Value = sha384CtxData.End()
});
}
if(enabled.HasFlag(EnableChecksum.Sha512))
{
dataChecksums.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.Sha512,
Value = sha512CtxData.End()
});
}
if(enabled.HasFlag(EnableChecksum.SpamSum))
{
dataChecksums.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.SpamSum,
Value = ssctxData.End()
});
}
if(enabled.HasFlag(EnableChecksum.Fletcher16))
{
dataChecksums.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.Fletcher16,
Value = f16CtxData.End()
});
}
if(!enabled.HasFlag(EnableChecksum.Fletcher32)) return dataChecksums;
dataChecksums.Add(new CommonTypes.AaruMetadata.Checksum
{
Type = ChecksumType.Fletcher32,
Value = f32CtxData.End()
});
return dataChecksums;
}
#region Threading helpers
struct HashPacket
{
public IChecksum Context;
public byte[] Data;
}
static void UpdateHash(object packet) => ((HashPacket)packet).Context.Update(((HashPacket)packet).Data);
#endregion Threading helpers
}
Reference in New Issue View Git Blame Copy Permalink