303 lines
9.6 KiB
C++
303 lines
9.6 KiB
C++
/**
|
|
* @file shred.cpp
|
|
* @brief shred drive
|
|
* @author hendrik schutter
|
|
* @date 22.08.2022
|
|
*/
|
|
|
|
#include "../include/reHDD.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
{
|
|
#endif
|
|
#include "../tfnoisegen/tfprng.h"
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
const static char *randomsrc = (char *)"/dev/urandom";
|
|
|
|
Shred::Shred()
|
|
{
|
|
}
|
|
|
|
Shred::~Shred()
|
|
{
|
|
}
|
|
|
|
/**
|
|
* \brief shred drive with shred
|
|
* \param pointer of Drive instance
|
|
* \return void
|
|
*/
|
|
int Shred::shredDrive(Drive *drive, int *ipSignalFd)
|
|
{
|
|
ostringstream address;
|
|
address << (void const *)&(*drive);
|
|
Logger::logThis()->info("Shred-Task started - Drive: " + drive->getModelName() + "-" + drive->getSerial() + " @" + address.str());
|
|
|
|
#ifdef DRYRUN
|
|
for (int i = 0; i <= 500; i++)
|
|
{
|
|
if (drive->state != Drive::SHRED_ACTIVE)
|
|
{
|
|
return 0;
|
|
}
|
|
drive->setTaskPercentage(i + 0.05);
|
|
write(*ipSignalFd, "A", 1);
|
|
usleep(20000);
|
|
}
|
|
#endif
|
|
|
|
#ifndef DRYRUN
|
|
const char *cpDrivePath = drive->getPath().c_str();
|
|
unsigned char ucKey[TFNG_KEY_SIZE];
|
|
|
|
// open random source
|
|
randomSrcFileDiscr = open(randomsrc, O_RDONLY | O_LARGEFILE);
|
|
if (randomSrcFileDiscr == -1)
|
|
{
|
|
std::string errorMsg(strerror(randomSrcFileDiscr));
|
|
Logger::logThis()->error("Shred-Task: Open random source failed! " + errorMsg + " - Drive: " + drive->getSerial());
|
|
perror(randomsrc);
|
|
cleanup();
|
|
return -1;
|
|
}
|
|
|
|
// open disk
|
|
driveFileDiscr = open(cpDrivePath, O_RDWR | O_LARGEFILE);
|
|
if (driveFileDiscr == -1)
|
|
{
|
|
std::string errorMsg(strerror(driveFileDiscr));
|
|
Logger::logThis()->error("Shred-Task: Open drive failed! " + errorMsg + " - Drive: " + drive->getSerial());
|
|
perror(cpDrivePath);
|
|
cleanup();
|
|
return -1;
|
|
}
|
|
|
|
// read key for random generator
|
|
ssize_t readRet = read(randomSrcFileDiscr, ucKey, sizeof(ucKey));
|
|
if (readRet <= 0)
|
|
{
|
|
std::string errorMsg(strerror(readRet));
|
|
Logger::logThis()->error("Shred-Task: Read random key failed! " + errorMsg + " - Drive: " + drive->getSerial());
|
|
perror(randomsrc);
|
|
cleanup();
|
|
return -1;
|
|
}
|
|
|
|
tfng_prng_seedkey(ucKey);
|
|
|
|
this->ulDriveByteSize = getDriveSizeInBytes(driveFileDiscr);
|
|
drive->sShredSpeed.chronoShredTimestamp = std::chrono::system_clock::now();
|
|
; // set inital timestamp for speed metric
|
|
drive->sShredSpeed.ulSpeedMetricBytesWritten = 0U; // uses to calculate speed metric
|
|
|
|
#ifdef LOG_LEVEL_HIGH
|
|
Logger::logThis()->info("Shred-Task: Bytes-Size of Drive: " + to_string(this->ulDriveByteSize) + " - Drive: " + drive->getSerial());
|
|
#endif
|
|
|
|
for (unsigned int uiShredIterationCounter = 0U; uiShredIterationCounter < SHRED_ITERATIONS; uiShredIterationCounter++)
|
|
{
|
|
unsigned long ulDriveByteCounter = 0U; // used for one shred-iteration to keep track of the current drive position
|
|
|
|
if (uiShredIterationCounter == (SHRED_ITERATIONS - 1))
|
|
{
|
|
// last shred iteration --> overwrite (just the write chunk) bytes with zeros instead with random data
|
|
memset(caTfngData, 0U, CHUNK_SIZE);
|
|
}
|
|
|
|
while (ulDriveByteCounter < ulDriveByteSize)
|
|
{
|
|
int iBytesToShred = 0; // Bytes that will be overwritten in this chunk-iteration
|
|
|
|
if (uiShredIterationCounter != (SHRED_ITERATIONS - 1))
|
|
{
|
|
// NOT last shred iteration --> generate new random data
|
|
tfng_prng_genrandom(caTfngData, TFNG_DATA_SIZE);
|
|
}
|
|
|
|
if ((ulDriveByteSize - ulDriveByteCounter) < CHUNK_SIZE)
|
|
{
|
|
iBytesToShred = (ulDriveByteSize - ulDriveByteCounter);
|
|
}
|
|
else
|
|
{
|
|
iBytesToShred = CHUNK_SIZE;
|
|
}
|
|
|
|
int iByteShredded = write(driveFileDiscr, caTfngData, iBytesToShred);
|
|
|
|
if (iByteShredded <= 0)
|
|
{
|
|
std::string errorMsg(strerror(iByteShredded));
|
|
Logger::logThis()->error("Shred-Task: Write to drive failed! " + errorMsg + " - Drive: " + drive->getSerial());
|
|
perror("unable to write random data");
|
|
cleanup();
|
|
return -1;
|
|
}
|
|
|
|
ulDriveByteCounter += iByteShredded;
|
|
ulDriveByteOverallCount += iByteShredded;
|
|
d32Percent = this->calcProgress();
|
|
drive->sShredSpeed.ulSpeedMetricBytesWritten += iByteShredded;
|
|
|
|
#ifdef LOG_LEVEL_HIGH
|
|
Logger::logThis()->info("Shred-Task: ByteCount: " + to_string(ulDriveByteCounter) + " - iteration: " + to_string((uiShredIterationCounter + 1)) + " - progress: " + to_string(d32Percent) + " - Drive: " + drive->getSerial());
|
|
#endif
|
|
if ((d32Percent - d32TmpPercent) >= 0.01)
|
|
{
|
|
// set shred percantage
|
|
drive->setTaskPercentage(d32TmpPercent);
|
|
d32TmpPercent = d32Percent;
|
|
// signal process in shreding
|
|
write(*ipSignalFd, "A", 1);
|
|
}
|
|
|
|
if (drive->state != Drive::SHRED_ACTIVE)
|
|
{
|
|
drive->setTaskPercentage(0);
|
|
d32Percent = 0.00;
|
|
d32TmpPercent = 0.00;
|
|
ulDriveByteCounter = 0U;
|
|
Logger::logThis()->info("Aborted shred for: " + drive->getModelName() + "-" + drive->getSerial());
|
|
cleanup();
|
|
return -1;
|
|
}
|
|
// end one chunk write
|
|
}
|
|
if (0 != iRewindDrive(driveFileDiscr))
|
|
{
|
|
Logger::logThis()->error("Shred-Task: Unable to rewind drive! - Drive: " + drive->getSerial());
|
|
cleanup();
|
|
return -1;
|
|
}
|
|
// end one shred iteration
|
|
}
|
|
// end of all shred iteratio
|
|
|
|
tfng_prng_seedkey(NULL); // reset random generator
|
|
|
|
drive->bWasShredded = true;
|
|
Logger::logThis()->info("Shred-Task finished - Drive: " + drive->getModelName() + "-" + drive->getSerial() + " @" + address.str());
|
|
#ifdef ZERO_CHECK
|
|
drive->state = Drive::CHECK_ACTIVE;
|
|
Logger::logThis()->info("Check-Task started - Drive: " + drive->getModelName() + "-" + drive->getSerial() + " @" + address.str());
|
|
drive->u32DriveChecksumAfterShredding = uiCalcChecksum(driveFileDiscr, drive, ipSignalFd);
|
|
#ifdef LOG_LEVEL_HIGH
|
|
if (drive->u32DriveChecksumAferShredding != 0)
|
|
{
|
|
Logger::logThis()->info("Shred-Task: Checksum not zero: " + to_string(drive->u32DriveChecksumAfterShredding) + " - Drive: " + drive->getSerial());
|
|
}
|
|
else
|
|
{
|
|
Logger::logThis()->info("Shred-Task: Checksum zero: " + to_string(drive->u32DriveChecksumAfterShredding) + " - Drive: " + drive->getSerial());
|
|
}
|
|
#endif
|
|
#endif
|
|
#endif
|
|
|
|
cleanup();
|
|
|
|
if ((drive->state == Drive::SHRED_ACTIVE) || (drive->state == Drive::CHECK_ACTIVE))
|
|
{
|
|
drive->state = Drive::NONE;
|
|
drive->setTaskPercentage(0.0);
|
|
Printer::getPrinter()->print(drive);
|
|
Logger::logThis()->info("Finished shred/check for: " + drive->getModelName() + "-" + drive->getSerial());
|
|
}
|
|
return 0;
|
|
}
|
|
/**
|
|
* \brief calc shredding progress in %
|
|
* \param current byte index of the drive
|
|
* \param current shred iteration
|
|
* \return double percentage
|
|
*/
|
|
double Shred::calcProgress()
|
|
{
|
|
unsigned int uiMaxShredIteration = SHRED_ITERATIONS;
|
|
|
|
#ifdef ZERO_CHECK
|
|
uiMaxShredIteration++; // increment because we will check after SHRED_ITERATIONS the drive for non-zero bytes
|
|
#endif
|
|
return (double)(((double)ulDriveByteOverallCount) / ((double)this->ulDriveByteSize * uiMaxShredIteration)) * 100.0f;
|
|
}
|
|
|
|
int Shred::iRewindDrive(fileDescriptor file)
|
|
{
|
|
if (0 != lseek(file, 0L, SEEK_SET))
|
|
{
|
|
perror("unable to rewind drive");
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
unsigned long Shred::getDriveSizeInBytes(fileDescriptor file)
|
|
{
|
|
unsigned long ulDriveSizeTmp = lseek(file, 0L, SEEK_END);
|
|
|
|
if (0 != iRewindDrive(file))
|
|
{
|
|
ulDriveSizeTmp = 0U;
|
|
}
|
|
|
|
#ifdef DEMO_DRIVE_SIZE
|
|
ulDriveSizeTmp = DEMO_DRIVE_SIZE;
|
|
#endif
|
|
return ulDriveSizeTmp;
|
|
}
|
|
|
|
unsigned int Shred::uiCalcChecksum(fileDescriptor file, Drive *drive, int *ipSignalFd)
|
|
{
|
|
unsigned int uiChecksum = 0;
|
|
unsigned long ulDriveByteCounter = 0U;
|
|
while (ulDriveByteCounter < ulDriveByteSize)
|
|
{
|
|
int iBytesToCheck = 0;
|
|
if ((ulDriveByteSize - ulDriveByteCounter) < CHUNK_SIZE)
|
|
{
|
|
iBytesToCheck = (ulDriveByteSize - ulDriveByteCounter);
|
|
}
|
|
else
|
|
{
|
|
iBytesToCheck = CHUNK_SIZE;
|
|
}
|
|
int iReadBytes = read(file, caReadBuffer, iBytesToCheck);
|
|
for (int iReadBytesCounter = 0U; iReadBytesCounter < iReadBytes; iReadBytesCounter++)
|
|
{
|
|
uiChecksum += caReadBuffer[iReadBytesCounter];
|
|
}
|
|
ulDriveByteCounter += iReadBytes;
|
|
ulDriveByteOverallCount += iReadBytes;
|
|
d32Percent = this->calcProgress();
|
|
drive->sShredSpeed.ulSpeedMetricBytesWritten += iReadBytes;
|
|
|
|
#ifdef LOG_LEVEL_HIGH
|
|
Logger::logThis()->info("Shred-Task (Checksum): ByteCount: " + to_string(ulDriveByteCounter) + " - progress: " + to_string(d32Percent) + " - Drive: " + drive->getSerial());
|
|
#endif
|
|
|
|
if (((d32Percent - d32TmpPercent) >= 0.01) || (d32Percent == 100.0))
|
|
{
|
|
drive->setTaskPercentage(d32TmpPercent);
|
|
d32TmpPercent = d32Percent;
|
|
#ifdef LOG_LEVEL_HIGH
|
|
Logger::logThis()->info("send progress signal to main loop (check)");
|
|
#endif
|
|
write(*ipSignalFd, "A", 1);
|
|
}
|
|
}
|
|
drive->bWasChecked = true;
|
|
return uiChecksum;
|
|
}
|
|
|
|
void Shred::cleanup()
|
|
{
|
|
close(driveFileDiscr);
|
|
close(randomSrcFileDiscr);
|
|
} |