/// <summary>Delegate method invoked by rcReadMessage.</summary>
protected void ExecuteReadMessage()
{
byte[] abMessageBytes;
string sErrorMessage, sMatchedKeyMessage;
PgpFile MessageFile;
PgpMessage NewMessage = null;
BytesAndTextUtility BytesAndText;
if (isExecuteReadMessage)
{
MessageFile = new PgpFile();
abMessageBytes = MessageFile.GetBytes(_sInputMessageFilePath, false);
switch (MessageFile.eStatus)
{
case PgpArmor.nStatus.CrcError: sErrorMessage = string.Format(sFileCrcError, _sInputKeyFilePath); break;
case PgpArmor.nStatus.ParseError: sErrorMessage = string.Format(sFileParseError, _sInputKeyFilePath); break;
case PgpArmor.nStatus.Undefined: sErrorMessage = string.Format(sFileError, _sInputKeyFilePath); break;
default: sErrorMessage = string.Empty; break;
}
if (string.IsNullOrEmpty(sErrorMessage))
{
NewMessage = new PgpMessage(abMessageBytes, _Cryptography);
switch (NewMessage.eStatus)
{
case PgpMessage.nStatus.ParseErrorRaw: sErrorMessage = string.Format(sFileParseError, _sInputMessageFilePath); break;
case PgpMessage.nStatus.ParseErrorSub: sErrorMessage = string.Format(sFileParseErrorSub, _sInputMessageFilePath); break;
case PgpMessage.nStatus.Undefined: sErrorMessage = string.Format(sFileError, _sInputMessageFilePath); break;
default: sErrorMessage = string.Empty; break;
}
}
if (string.IsNullOrEmpty(sErrorMessage))
{
if (NewMessage != null) // just to be sure, but this should always be true
{
NewMessage.MatchPublicKeys(_ltTokens);
BytesAndText = new BytesAndTextUtility();
foreach (PgpPublicKeyEncryptedKey WrappedKey in NewMessage.ltPublicKeyEncryptedKeys)
{
if (WrappedKey.MatchedPublicKey == null)
{
BytesAndText.abBytes = WrappedKey.abPublicKeyId;
sMatchedKeyMessage = string.Format(sPublicKeyNotMatched, BytesAndText.sHexadecimalBytes);
}
else
sMatchedKeyMessage = string.Format(sPublicKeyMatched, WrappedKey.sUserId);
_blMessages.Add(new Property(DateTime.Now, sMatchedKeyMessage));
}
}
}
else
{
_blMessages.Add(new Property(DateTime.Now, sErrorMessage));
eMenuTab = nMenuTab.Progress;
}
}
}
/// <summary></summary>
/// <param name=""></param>
/// <param name=""></param>
public byte[] Parse(string sArmor, bool isKey)
{
byte[] abCrc24, abReturn = null;
int i, iCrc24Value;
Crc24 Crc24Computed;
BytesAndTextUtility StringConverter;
nArmorParserState eArmorParserState = nArmorParserState.Start;
string sArmoredData, sChecksum, sHeader;
string[] asLines;
if (string.IsNullOrEmpty(sArmor))
{
_eStatus = nStatus.ParseError;
}
else
{
asLines = sArmor.Split(asDelimiters, StringSplitOptions.None);
sArmoredData = sChecksum = sHeader = string.Empty;
for (i = 0; i < asLines.Length; i++)
{
switch (eArmorParserState)
{
case nArmorParserState.Start:
eArmorParserState = isKey ? ParseCheckForKeyHeader(asLines[i]) : ParseCheckForMessageHeader(asLines[i]);
if (eArmorParserState == nArmorParserState.Header)
{
sHeader = asLines[i];
}
break;
case nArmorParserState.Header:
case nArmorParserState.KeyValue: eArmorParserState = ParseCheckForBlankLine(asLines[i]); break;
case nArmorParserState.BlankLine:
case nArmorParserState.ArmoredData:
eArmorParserState = ParseCheckForData(asLines[i], sHeader);
if (eArmorParserState == nArmorParserState.ArmoredData)
{
sArmoredData += asLines[i];
}
else if (eArmorParserState == nArmorParserState.Checksum)
{
sChecksum = asLines[i];
}
break;
case nArmorParserState.Checksum: eArmorParserState = ParseCheckForFooter(asLines[i], sHeader); break;
}
}
if (eArmorParserState == nArmorParserState.Success)
{
StringConverter = new BytesAndTextUtility(sArmoredData);
abReturn = StringConverter.abBase64StringBytes;
if (abReturn == null)
{
_eStatus = nStatus.ParseError;
}
else
{
_eStatus = nStatus.OK;
if (!string.IsNullOrEmpty(sChecksum))
{
StringConverter = new BytesAndTextUtility(sChecksum.Substring(1));
abCrc24 = StringConverter.abBase64StringBytes;
if ((abCrc24 == null) || (abCrc24.Length != Crc24.ciCrc24Length))
{
_eStatus = nStatus.ParseError;
abReturn = null;
}
else
{
iCrc24Value = (abCrc24[0] << 16) | (abCrc24[1] << 8) | abCrc24[2];
Crc24Computed = new Crc24(abReturn);
if (iCrc24Value != Crc24Computed.iCrc24)
{
_eStatus = nStatus.CrcError;
abReturn = null;
}
}
}
}
}
else
{
_eStatus = nStatus.ParseError;
}
}
return(abReturn);
}
