/**
* instead of a password, it's also possible to decrypt via certificate.
* Warning: this code is experimental and hasn't been validated
*
* @see <a href="http://social.msdn.microsoft.com/Forums/en-US/cc9092bb-0c82-4b5b-ae21-abf643bdb37c/agile-encryption-with-certificates">Agile encryption with certificates</a>
*
* @param keyPair
* @param x509
* @return true, when the data can be successfully decrypted with the given private key
* @throws GeneralSecurityException
*/
public bool VerifyPassword(KeyPair keyPair, X509Certificate x509)
{
AgileEncryptionVerifier ver = (AgileEncryptionVerifier)builder.GetVerifier();
AgileEncryptionHeader header = (AgileEncryptionHeader)builder.GetHeader();
HashAlgorithm hashAlgo = header.HashAlgorithm;
CipherAlgorithm cipherAlgo = header.CipherAlgorithm;
int blockSize = header.BlockSize;
AgileCertificateEntry ace = null;
foreach (AgileCertificateEntry aceEntry in ver.GetCertificates())
{
if (x509.Equals(aceEntry.x509))
{
ace = aceEntry;
break;
}
}
if (ace == null)
{
return(false);
}
Cipher cipher = Cipher.GetInstance("RSA");
cipher.Init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
byte[] keyspec = cipher.DoFinal(ace.encryptedKey);
SecretKeySpec secretKey = new SecretKeySpec(keyspec, ver.CipherAlgorithm.jceId);
Mac x509Hmac = CryptoFunctions.GetMac(hashAlgo);
x509Hmac.Init(secretKey);
byte[] certVerifier = x509Hmac.DoFinal(ace.x509.GetEncoded());
byte[] vec = CryptoFunctions.GenerateIv(hashAlgo, header.KeySalt, kIntegrityKeyBlock, blockSize);
cipher = GetCipher(secretKey, cipherAlgo, ver.ChainingMode, vec, Cipher.DECRYPT_MODE);
byte[] hmacKey = cipher.DoFinal(header.GetEncryptedHmacKey());
hmacKey = GetBlock0(hmacKey, hashAlgo.hashSize);
vec = CryptoFunctions.GenerateIv(hashAlgo, header.KeySalt, kIntegrityValueBlock, blockSize);
cipher = GetCipher(secretKey, cipherAlgo, ver.ChainingMode, vec, Cipher.DECRYPT_MODE);
byte[] hmacValue = cipher.DoFinal(header.GetEncryptedHmacValue());
hmacValue = GetBlock0(hmacValue, hashAlgo.hashSize);
if (Arrays.Equals(ace.certVerifier, certVerifier))
{
SetSecretKey(secretKey);
SetIntegrityHmacKey(hmacKey);
SetIntegrityHmacValue(hmacValue);
return(true);
}
else
{
return(false);
}
}
/**
* Set decryption password
*/
public override bool VerifyPassword(String password)
{
AgileEncryptionVerifier ver = (AgileEncryptionVerifier)builder.GetVerifier();
AgileEncryptionHeader header = (AgileEncryptionHeader)builder.GetHeader();
HashAlgorithm hashAlgo = header.HashAlgorithm;
CipherAlgorithm cipherAlgo = header.CipherAlgorithm;
int blockSize = header.BlockSize;
int keySize = header.KeySize / 8;
byte[] pwHash = CryptoFunctions.HashPassword(password, ver.HashAlgorithm, ver.Salt, ver.SpinCount);
/**
* encryptedVerifierHashInput: This attribute MUST be generated by using the following steps:
* 1. Generate a random array of bytes with the number of bytes used specified by the saltSize
* attribute.
* 2. Generate an encryption key as specified in section 2.3.4.11 by using the user-supplied password,
* the binary byte array used to create the saltValue attribute, and a blockKey byte array
* consisting of the following bytes: 0xfe, 0xa7, 0xd2, 0x76, 0x3b, 0x4b, 0x9e, and 0x79.
* 3. Encrypt the random array of bytes generated in step 1 by using the binary form of the saltValue
* attribute as an Initialization vector as specified in section 2.3.4.12. If the array of bytes is not an
* integral multiple of blockSize bytes, pad the array with 0x00 to the next integral multiple of
* blockSize bytes.
* 4. Use base64 to encode the result of step 3.
*/
byte[] verfierInputEnc = hashInput(builder, pwHash, kVerifierInputBlock, ver.EncryptedVerifier, Cipher.DECRYPT_MODE);
SetVerifier(verfierInputEnc);
MessageDigest hashMD = CryptoFunctions.GetMessageDigest(hashAlgo);
byte[] verifierHash = hashMD.Digest(verfierInputEnc);
/**
* encryptedVerifierHashValue: This attribute MUST be generated by using the following steps:
* 1. Obtain the hash value of the random array of bytes generated in step 1 of the steps for
* encryptedVerifierHashInput.
* 2. Generate an encryption key as specified in section 2.3.4.11 by using the user-supplied password,
* the binary byte array used to create the saltValue attribute, and a blockKey byte array
* consisting of the following bytes: 0xd7, 0xaa, 0x0f, 0x6d, 0x30, 0x61, 0x34, and 0x4e.
* 3. Encrypt the hash value obtained in step 1 by using the binary form of the saltValue attribute as
* an Initialization vector as specified in section 2.3.4.12. If hashSize is not an integral multiple of
* blockSize bytes, pad the hash value with 0x00 to an integral multiple of blockSize bytes.
* 4. Use base64 to encode the result of step 3.
*/
byte[] verifierHashDec = hashInput(builder, pwHash, kHashedVerifierBlock, ver.EncryptedVerifierHash, Cipher.DECRYPT_MODE);
verifierHashDec = CryptoFunctions.GetBlock0(verifierHashDec, hashAlgo.hashSize);
/**
* encryptedKeyValue: This attribute MUST be generated by using the following steps:
* 1. Generate a random array of bytes that is the same size as specified by the
* Encryptor.KeyData.keyBits attribute of the parent element.
* 2. Generate an encryption key as specified in section 2.3.4.11, using the user-supplied password,
* the binary byte array used to create the saltValue attribute, and a blockKey byte array
* consisting of the following bytes: 0x14, 0x6e, 0x0b, 0xe7, 0xab, 0xac, 0xd0, and 0xd6.
* 3. Encrypt the random array of bytes generated in step 1 by using the binary form of the saltValue
* attribute as an Initialization vector as specified in section 2.3.4.12. If the array of bytes is not an
* integral multiple of blockSize bytes, pad the array with 0x00 to an integral multiple of
* blockSize bytes.
* 4. Use base64 to encode the result of step 3.
*/
byte[] keyspec = hashInput(builder, pwHash, kCryptoKeyBlock, ver.EncryptedKey, Cipher.DECRYPT_MODE);
keyspec = CryptoFunctions.GetBlock0(keyspec, keySize);
SecretKeySpec secretKey = new SecretKeySpec(keyspec, ver.CipherAlgorithm.jceId);
/**
* 1. Obtain the intermediate key by decrypting the encryptedKeyValue from a KeyEncryptor
* Contained within the KeyEncryptors sequence. Use this key for encryption operations in the
* remaining steps of this section.
* 2. Generate a random array of bytes, known as Salt, of the same length as the value of the
* KeyData.HashSize attribute.
* 3. Encrypt the random array of bytes generated in step 2 by using the binary form of the
* KeyData.saltValue attribute and a blockKey byte array consisting of the following bytes: 0x5f,
* 0xb2, 0xad, 0x01, 0x0c, 0xb9, 0xe1, and 0xf6 used to form an Initialization vector as specified in
* section 2.3.4.12. If the array of bytes is not an integral multiple of blockSize bytes, pad the
* array with 0x00 to the next integral multiple of blockSize bytes.
* 4. Assign the encryptedHmacKey attribute to the base64-encoded form of the result of step 3.
*/
byte[] vec = CryptoFunctions.GenerateIv(hashAlgo, header.KeySalt, kIntegrityKeyBlock, blockSize);
Cipher cipher = CryptoFunctions.GetCipher(secretKey, cipherAlgo, ver.ChainingMode, vec, Cipher.DECRYPT_MODE);
byte[] hmacKey = cipher.DoFinal(header.GetEncryptedHmacKey());
hmacKey = CryptoFunctions.GetBlock0(hmacKey, hashAlgo.hashSize);
/**
* 5. Generate an HMAC, as specified in [RFC2104], of the encrypted form of the data (message),
* which the DataIntegrity element will verify by using the Salt generated in step 2 as the key.
* Note that the entire EncryptedPackage stream (1), including the StreamSize field, MUST be
* used as the message.
* 6. Encrypt the HMAC as in step 3 by using a blockKey byte array consisting of the following bytes:
* 0xa0, 0x67, 0x7f, 0x02, 0xb2, 0x2c, 0x84, and 0x33.
* 7. Assign the encryptedHmacValue attribute to the base64-encoded form of the result of step 6.
*/
vec = CryptoFunctions.GenerateIv(hashAlgo, header.KeySalt, kIntegrityValueBlock, blockSize);
cipher = CryptoFunctions.GetCipher(secretKey, cipherAlgo, ver.ChainingMode, vec, Cipher.DECRYPT_MODE);
byte[] hmacValue = cipher.DoFinal(header.GetEncryptedHmacValue());
hmacValue = CryptoFunctions.GetBlock0(hmacValue, hashAlgo.hashSize);
if (Arrays.Equals(verifierHashDec, verifierHash))
{
SetSecretKey(secretKey);
SetIntegrityHmacKey(hmacKey);
SetIntegrityHmacValue(hmacValue);
return(true);
}
else
{
return(false);
}
}
protected EncryptionDocument CreateEncryptionDocument()
{
AgileEncryptionVerifier ver = builder.GetVerifier();
AgileEncryptionHeader header = builder.GetHeader();
EncryptionDocument ed = EncryptionDocument.NewInstance();
CT_Encryption edRoot = ed.AddNewEncryption();
CT_KeyData keyData = edRoot.AddNewKeyData();
CT_KeyEncryptors keyEncList = edRoot.AddNewKeyEncryptors();
CT_KeyEncryptor keyEnc = keyEncList.AddNewKeyEncryptor();
keyEnc.uri = (/*setter*/ passwordUri);
CT_PasswordKeyEncryptor keyPass = keyEnc.AddNewEncryptedPasswordKey();
keyPass.spinCount = (uint)ver.SpinCount;
keyData.saltSize = (uint)header.BlockSize;
keyPass.saltSize = (uint)header.BlockSize;
keyData.blockSize = (uint)header.BlockSize;
keyPass.blockSize = (uint)header.BlockSize;
keyData.keyBits = (uint)header.KeySize;
keyPass.keyBits = (uint)header.KeySize;
HashAlgorithm hashAlgo = header.HashAlgorithm;
keyData.hashSize = (uint)hashAlgo.hashSize;
keyPass.hashSize = (uint)hashAlgo.hashSize;
ST_CipherAlgorithm?xmlCipherAlgo = (ST_CipherAlgorithm?)Enum.Parse(typeof(ST_CipherAlgorithm), header.CipherAlgorithm.xmlId);
if (xmlCipherAlgo == null)
{
throw new EncryptedDocumentException("CipherAlgorithm " + header.CipherAlgorithm + " not supported.");
}
keyData.cipherAlgorithm = (/*setter*/ xmlCipherAlgo.Value);
keyPass.cipherAlgorithm = (/*setter*/ xmlCipherAlgo.Value);
switch (header.ChainingMode.jceId)
{
case "cbc":
keyData.cipherChaining = (/*setter*/ ST_CipherChaining.ChainingModeCBC);
keyPass.cipherChaining = (/*setter*/ ST_CipherChaining.ChainingModeCBC);
break;
case "cfb":
keyData.cipherChaining = (/*setter*/ ST_CipherChaining.ChainingModeCFB);
keyPass.cipherChaining = (/*setter*/ ST_CipherChaining.ChainingModeCFB);
break;
default:
throw new EncryptedDocumentException("ChainingMode " + header.ChainingMode + " not supported.");
}
ST_HashAlgorithm?xmlHashAlgo = (ST_HashAlgorithm?)Enum.Parse(typeof(ST_HashAlgorithm), hashAlgo.ecmaString);
if (xmlHashAlgo == null)
{
throw new EncryptedDocumentException("HashAlgorithm " + hashAlgo + " not supported.");
}
keyData.hashAlgorithm = (/*setter*/ xmlHashAlgo.Value);
keyPass.hashAlgorithm = (/*setter*/ xmlHashAlgo.Value);
keyData.saltValue = (/*setter*/ header.KeySalt);
keyPass.saltValue = (/*setter*/ ver.Salt);
keyPass.encryptedVerifierHashInput = (/*setter*/ ver.EncryptedVerifier);
keyPass.encryptedVerifierHashValue = (/*setter*/ ver.EncryptedVerifierHash);
keyPass.encryptedKeyValue = (/*setter*/ ver.EncryptedKey);
CT_DataIntegrity hmacData = edRoot.AddNewDataIntegrity();
hmacData.encryptedHmacKey = (/*setter*/ header.GetEncryptedHmacKey());
hmacData.encryptedHmacValue = (/*setter*/ header.GetEncryptedHmacValue());
foreach (AgileCertificateEntry ace in ver.GetCertificates())
{
keyEnc = keyEncList.AddNewKeyEncryptor();
keyEnc.uri = (/*setter*/ certificateUri);
CT_CertificateKeyEncryptor certData = keyEnc.AddNewEncryptedCertificateKey();
try {
certData.X509Certificate = ace.x509.GetEncoded();
} catch (Exception e) {
throw new EncryptedDocumentException(e);
}
certData.encryptedKeyValue = (/*setter*/ ace.encryptedKey);
certData.certVerifier = (/*setter*/ ace.certVerifier);
}
return(ed);
}
