void AdvancedSearchState::SetSizeFilter(Ui::MainWindow* window, SearchParameter& parameter)
{
QString option = window->sizeComboBox->currentText();
bool sizeIgnored = option.indexOf("Ignore") != -1;
qint64 lowerSize = 0,
upperSize = 0;
if (sizeIgnored == false)
{
bool between = option.indexOf("Between") != -1;
bool larger = option.indexOf("Larger") != -1;
bool smaller = option.indexOf("Smaller") != -1;
if (larger)
lowerSize = units2bytes(QString("%1 %2").arg(window->sizeLineEdit->text()).arg(
chop(window->sizeUnitsComboBox->currentText(), 4))); // chop 'ytes'
if (smaller)
upperSize = units2bytes(QString("%1 %2").arg(window->sizeLineEdit->text()).arg(
chop(window->sizeUnitsComboBox->currentText(), 4))); // chop 'ytes'
if (between)
{
lowerSize = units2bytes(QString("%1 %2").arg(window->sizeLineEdit->text()).arg(
chop(window->sizeUnitsComboBox->currentText(), 4))); // chop 'ytes'
upperSize = units2bytes(QString("%1 %2").arg(window->sizeLineEdit2->text()).arg(
chop(window->sizeUnitsComboBox2->currentText(), 4)));
}
}
parameter.phaseOneParam->SetSizeLowerBound(lowerSize);
parameter.phaseOneParam->SetSizeUpperBound(upperSize);
}
int
rsa_private_encrypt(unitptr outbuf, byteptr inbuf, short bytes,
unitptr E, unitptr D, unitptr P, unitptr Q, unitptr U, unitptr N)
/* Encrypt a message digest with a private key.
* Returns <0 on error:
* -1: generic error
* -4: Key too big
* -5: Key too small
*/
{
unit temp[MAX_UNIT_PRECISION];
unit DP[MAX_UNIT_PRECISION], DQ[MAX_UNIT_PRECISION];
byte *p;
int i;
unsigned int blocksize;
/* PGP doesn't store these coefficents, so we need to compute them. */
mp_move(temp,P);
mp_dec(temp);
mp_mod(DP,D,temp);
mp_move(temp,Q);
mp_dec(temp);
mp_mod(DQ,D,temp);
p = (byte *)temp;
/* We are building the mpi in place, except for a possible
* byte-order swap to little-endian at the end. Thus, we
* need to fill the buffer with leading 0's in the unused
* most significant byte positions.
*/
blocksize = countbytes(N) - 1; /* Space available for data */
for (i = units2bytes(global_precision) - blocksize; i > 0; --i)
*p++ = 0;
i = blocksize - 2 - bytes; /* Padding needed */
i -= sizeof(asn_array); /* Space for type encoding */
if (i < 0) {
i = -4; /* Error code */
goto Cleanup;
}
*p++ = MD_ENCRYPTED_BYTE; /* Type byte */
memset(p, ~0, i); /* All 1's padding */
p += i;
*p++ = 0; /* Zero framing byte */
memcpy(p, asn_array, sizeof(asn_array)); /* ASN data */
p += sizeof(asn_array);
memcpy(p, inbuf, bytes); /* User data */
mp_convert_order((byte *)temp);
i = mp_modexp_crt(outbuf, temp, P, Q, DP, DQ, U); /* Encrypt */
if (i < 0)
i = -1;
Cleanup:
burn(temp);
return i;
} /* rsa_private_encrypt */
/******************************************************************************
* LessThan(): primary comparator override.
******************************************************************************/
bool SortFilterProxyModel::lessThan(const QModelIndex &left,
const QModelIndex &right) const {
QVariant leftData = sourceModel()->data(left),
rightData = sourceModel()->data(right);
QString leftString = leftData.toString(),
rightString = rightData.toString();
int leftInt = leftData.toInt(),
rightInt = rightData.toInt();
if (left.column() == 1 && right.column() == 1)
return units2bytes(leftString) < units2bytes(rightString);
if (left.column() == 2 && right.column() == 2)
return leftInt < rightInt;
if (left.column() == 4 && right.column() == 4)
return qstring2qdatetime(leftString) < qstring2qdatetime(rightString);
return QString::localeAwareCompare(leftString, rightString) < 0;
}
int
rsa_public_encrypt(unitptr outbuf, byteptr inbuf, short bytes,
unitptr E, unitptr N)
/* Encrypt a DEK with a public key. Returns 0 on success.
* <0 means there was an error.
* -1: Generic error
* -3: Key too big
* -4: Key too small
*/
{
unit temp[MAX_UNIT_PRECISION];
unsigned int blocksize;
int i; /* Temporary, and holds error codes */
byte *p = (byte *)temp;
/*
* We are building the mpi in place, except for a possible
* byte-order swap to little-endian at the end. Thus, we
* need to fill the buffer with leading 0's in the unused
* most significant byte positions.
*/
blocksize = countbytes(N) - 1; /* Bytes available for user data */
for (i = units2bytes(global_precision) - blocksize; i > 0; --i)
*p++ = 0;
/*
* Both the PKCS and PGP 2.0 key formats add a type byte, and a
* a framing byte of 0 to the user data. The remaining space
* is filled with random padding. (PKCS requires that there be
* at least 1 byte of padding.)
*/
i = blocksize - 2 - bytes;
if (i < 1) /* Less than minimum padding? */
return -4;
*p++ = CK_ENCRYPTED_BYTE; /* Type byte */
while (i) /* Non-zero random padding */
if ((*p = cryptRandByte()))
++p, --i;
*p++ = 0; /* Framing byte */
memcpy(p, inbuf, bytes); /* User data */
mp_convert_order((byte *)temp); /* Convert buffer to MPI */
i = mp_modexp(outbuf, temp, E, N); /* Do the encryption */
if (i < 0)
i = -1;
Cleanup:
mp_burn(temp);
return i < 0 ? i : 0;
} /* rsa_public_encrypt */
/* We expect to find random padding and an encryption key */
int
rsa_private_decrypt(byteptr outbuf, unitptr inbuf,
unitptr E, unitptr D, unitptr P, unitptr Q, unitptr U, unitptr N)
/* Decrypt an encryption key using a private key. Returns the number of bytes
* extracted, or <0 on error.
* -1: Generic error
* -3: Key too big
* -4: Key too small
* -5: Maybe malformed RSA
* -7: Unknown conventional algorithm
* -9: Malformed RSA packet
*/
{
byte *back;
byte *front;
unsigned int blocksize;
unit temp[MAX_UNIT_PRECISION];
unit DP[MAX_UNIT_PRECISION], DQ[MAX_UNIT_PRECISION];
int i;
/* PGP doesn't store (d mod p-1) and (d mod q-1), so compute 'em */
mp_move(temp,P);
mp_dec(temp);
mp_mod(DP,D,temp);
mp_move(temp,Q);
mp_dec(temp);
mp_mod(DQ,D,temp);
i = mp_modexp_crt(temp, inbuf, P, Q, DP, DQ, U);
mp_burn(DP);
mp_burn(DQ);
if (i < 0) {
mp_burn(temp);
return -1;
}
mp_convert_order((byte *)temp);
front = (byte *)temp; /* Start of block */
i = units2bytes(global_precision);
back = (byte *)front + i; /* End of block */
blocksize = countbytes(N) - 1;
i -= blocksize; /* Expected # of leading 0's */
if (i < 0) /* This shouldn't happen */
goto Corrupted;
while (i--) /* Extra bytes should be 0 */
if (*front++)
goto Corrupted;
/* How to distinguish old PGP from PKCS formats.
* PGP packets have a trailing type byte (CK_ENCRYPTED_BYTE),
* while PKCS formats have it leading.
*/
if (front[0] != CK_ENCRYPTED_BYTE && back[-1] == CK_ENCRYPTED_BYTE) {
/* PGP 2.0 format - padding at the end */
if (back[-1] != CK_ENCRYPTED_BYTE)
goto Corrupted;
while (*--back) /* Skip non-zero random padding */
;
} else {
/* PKCS format - padding at the beginning */
if (*front++ != CK_ENCRYPTED_BYTE)
goto Corrupted;
while (*front++) /* Skip non-zero random padding */
;
}
if (back <= front)
goto Corrupted;
blocksize = back-front;
memcpy(outbuf, front, blocksize);
mp_burn(temp);
return blocksize;
Corrupted:
mp_burn(temp);
return -9;
} /* rsa_private_decrypt */
/* Thus, we expect constant padding and the MIC ASN sequence */
int
rsa_public_decrypt(byteptr outbuf, unitptr inbuf,
unitptr E, unitptr N)
/* Decrypt a message digest using a public key. Returns the number of bytes
* extracted, or <0 on error.
* -1: Corrupted packet.
* -3: Key too big
* -4: Key too small
* -5: Maybe malformed RSA packet
* -7: Unknown conventional algorithm
* -9: Malformed RSA packet
*/
{
unit temp[MAX_UNIT_PRECISION];
unsigned int blocksize;
int i;
byte *front, *back;
i = mp_modexp(temp, inbuf, E, N);
if (i < 0) {
mp_burn(temp);
return -1;
}
mp_convert_order((byte *)temp);
blocksize = countbytes(N) - 1;
front = (byte *)temp; /* Points to start of block */
i = units2bytes(global_precision);
back = front + i; /* Points to end of block */
i -= countbytes(N) - 1; /* Expected leading 0's */
/*
* Strip off the padding. This handles both PKCS and PGP 2.0
* formats. If we're using RSAREF2, we use the padding-removal
* code in RSAPublicDecrypt, which accepts only PKCS style.
* Oh, well.
*/
if (i < 0) /* This shouldn't happen */
goto ErrorReturn;
while (i--) /* Extra bytes should be 0 */
if (*front++)
goto ErrorReturn;
/* How to distinguish old PGP from PKCS formats.
* The old PGP format ends in a trailing type byte, with
* all 1's padding before that. The PKCS format ends in
* 16 bytes of message digest, preceded by an ASN string
* which is not all 1's.
*/
if (back[-1] == MD_ENCRYPTED_BYTE &&
back[-17] == 0xff && back[-18] == 0xff) {
/* Old PGP format: Padding is at the end */
if (*--back != MD_ENCRYPTED_BYTE)
goto ErrorReturn;
if (*front++ != MD5_ALGORITHM_BYTE) {
mp_burn(temp);
return -7;
}
while (*--back == 0xff) /* Skip constant padding */
;
if (*back) /* It should end with a zero */
goto ErrorReturn;
} else {
/* PKCS format: padding at the beginning */
if (*front++ != MD_ENCRYPTED_BYTE)
goto ErrorReturn;
while (*front++ == 0xff) /* Skip constant padding */
;
if (front[-1]) /* First non-FF byte should be 0 */
goto ErrorReturn;
/* Then comes the ASN header */
if (memcmp(front, asn_array, sizeof(asn_array))) {
mp_burn(temp);
return -7;
}
front += sizeof(asn_array);
}
/* We're done - copy user data to outbuf */
if (back < front)
goto ErrorReturn;
blocksize = back-front;
memcpy(outbuf, front, blocksize);
mp_burn(temp);
return blocksize;
ErrorReturn:
mp_burn(temp);
return -9;
} /* rsa_public_decrypt */
