1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Security
{
using System.Security.Cryptography;
using System.ServiceModel.Channels;
using System.Xml;
class EncryptedData : EncryptedType
{
internal static readonly XmlDictionaryString ElementName = XD.XmlEncryptionDictionary.EncryptedData;
internal static readonly string ElementType = XmlEncryptionStrings.ElementType;
internal static readonly string ContentType = XmlEncryptionStrings.ContentType;
SymmetricAlgorithm algorithm;
byte[] decryptedBuffer;
ArraySegment<byte> buffer;
byte[] iv;
byte[] cipherText;
protected override XmlDictionaryString OpeningElementName
{
get { return ElementName; }
}
void EnsureDecryptionSet()
{
if (this.State == EncryptionState.DecryptionSetup)
{
SetPlainText();
}
else if (this.State != EncryptionState.Decrypted)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SR.GetString(SR.BadEncryptionState)));
}
}
protected override void ForceEncryption()
{
CryptoHelper.GenerateIVAndEncrypt(this.algorithm, this.buffer, out this.iv, out this.cipherText);
this.State = EncryptionState.Encrypted;
this.buffer = new ArraySegment<byte>(CryptoHelper.EmptyBuffer);
}
public byte[] GetDecryptedBuffer()
{
EnsureDecryptionSet();
return this.decryptedBuffer;
}
protected override void ReadCipherData(XmlDictionaryReader reader)
{
this.cipherText = reader.ReadContentAsBase64();
}
protected override void ReadCipherData(XmlDictionaryReader reader, long maxBufferSize)
{
this.cipherText = SecurityUtils.ReadContentAsBase64(reader, maxBufferSize);
}
void SetPlainText()
{
this.decryptedBuffer = CryptoHelper.ExtractIVAndDecrypt(this.algorithm, this.cipherText, 0, this.cipherText.Length);
this.State = EncryptionState.Decrypted;
}
public void SetUpDecryption(SymmetricAlgorithm algorithm)
{
if (this.State != EncryptionState.Read)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SR.GetString(SR.BadEncryptionState)));
}
if (algorithm == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("algorithm");
}
this.algorithm = algorithm;
this.State = EncryptionState.DecryptionSetup;
}
public void SetUpEncryption(SymmetricAlgorithm algorithm, ArraySegment<byte> buffer)
{
if (this.State != EncryptionState.New)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SR.GetString(SR.BadEncryptionState)));
}
if (algorithm == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("algorithm");
}
this.algorithm = algorithm;
this.buffer = buffer;
this.State = EncryptionState.EncryptionSetup;
}
protected override void WriteCipherData(XmlDictionaryWriter writer)
{
writer.WriteBase64(this.iv, 0, this.iv.Length);
writer.WriteBase64(this.cipherText, 0, this.cipherText.Length);
}
}
}
|
