| 1 |
// Licensed to the .NET Foundation under one or more agreements. |
| 2 |
// The .NET Foundation licenses this file to you under the MIT license. |
| 3 |
// See the LICENSE file in the project root for more information. |
| 4 |
|
| 5 |
using System.Security.Cryptography.X509Certificates; |
| 6 |
using Xunit; |
| 7 |
|
| 8 |
using Test.Cryptography; |
| 9 |
using System.Security.Cryptography.Pkcs.Tests; |
| 10 |
|
| 11 |
namespace System.Security.Cryptography.Pkcs.EnvelopedCmsTests.Tests |
| 12 |
{ |
| 13 |
public static partial class ContentEncryptionAlgorithmTests |
| 14 |
{ |
| 15 |
public static bool SupportsRc4 => PlatformDetection.IsWindows; |
| 16 |
public static bool DoesNotSupportRc4 => !SupportsRc4; |
| 17 |
|
| 18 |
[Fact] |
| 19 |
public static void EncryptionAlgorithmRc2_InvalidKeyLength() |
| 20 |
{ |
| 21 |
// For desktop compat, variable key length ciphers throw an error if the key length provided |
| 22 |
// is not a multiple of 8. |
| 23 |
AlgorithmIdentifier algorithm = new AlgorithmIdentifier(new Oid(Oids.Rc2), 3); |
| 24 |
ContentInfo contentInfo = new ContentInfo(new byte[] { 1, 2, 3 }); |
| 25 |
EnvelopedCms ecms = new EnvelopedCms(contentInfo, algorithm); |
| 26 |
using (X509Certificate2 cert = Certificates.RSAKeyTransfer1.GetCertificate()) |
| 27 |
{ |
| 28 |
CmsRecipient cmsRecipient = new CmsRecipient(cert); |
| 29 |
Assert.ThrowsAny<CryptographicException>(() => ecms.Encrypt(cmsRecipient)); |
| 30 |
} |
| 31 |
} |
| 32 |
|
| 33 |
[Fact] |
| 34 |
public static void DecodeAlgorithmRc2_128_RoundTrip() |
| 35 |
{ |
| 36 |
AlgorithmIdentifier algorithm = new AlgorithmIdentifier(new Oid(Oids.Rc2)); |
| 37 |
ContentInfo contentInfo = new ContentInfo(new byte[] { 1, 2, 3 }); |
| 38 |
EnvelopedCms ecms = new EnvelopedCms(contentInfo, algorithm); |
| 39 |
using (X509Certificate2 cert = Certificates.RSAKeyTransfer1.GetCertificate()) |
| 40 |
{ |
| 41 |
CmsRecipient cmsRecipient = new CmsRecipient(cert); |
| 42 |
ecms.Encrypt(cmsRecipient); |
| 43 |
} |
| 44 |
byte[] encodedMessage = ecms.Encode(); |
| 45 |
VerifyAlgorithmRc2_128(encodedMessage); |
| 46 |
} |
| 47 |
|
| 48 |
[Fact] |
| 49 |
public static void DecodeAlgorithmRc2_128_FixedValue() |
| 50 |
{ |
| 51 |
byte[] encodedMessage = |
| 52 |
("3082011306092a864886f70d010703a0820104308201000201003181c83081c5020100302e301a311830160603550403130f" |
| 53 |
+ "5253414b65795472616e7366657231021031d935fb63e8cfab48a0bf7b397b67c0300d06092a864886f70d01010105000481" |
| 54 |
+ "802fb2f6a7ccc1c696177c1ddb5ac92ab7f556dce4d21e924c37a06fbdb7015fd35dee9726f6301ca86af50b14275bf34584" |
| 55 |
+ "3571848bf6f55281c75fb67adc9c63fac5c4427b38f4fab1567f2f08063a786059f9850c79ff202d1b556e8c90e41f977090" |
| 56 |
+ "3c2d84a9046a372a0619a29713179304355750c9f6c180d1cc92d9b22b303006092a864886f70d010701301906082a864886" |
| 57 |
+ "f70d0302300d02013a04086bcd05b70546e632800810f6c8d0e0466ee6").HexToByteArray(); |
| 58 |
VerifyAlgorithmRc2_128(encodedMessage); |
| 59 |
} |
| 60 |
|
| 61 |
private static void VerifyAlgorithmRc2_128(byte[] encodedMessage) |
| 62 |
{ |
| 63 |
EnvelopedCms ecms = new EnvelopedCms(); |
| 64 |
ecms.Decode(encodedMessage); |
| 65 |
AlgorithmIdentifier algorithm = ecms.ContentEncryptionAlgorithm; |
| 66 |
Assert.NotNull(algorithm.Oid); |
| 67 |
Assert.Equal(Oids.Rc2, algorithm.Oid.Value); |
| 68 |
Assert.Equal(128, algorithm.KeyLength); |
| 69 |
} |
| 70 |
|
| 71 |
[Fact] |
| 72 |
public static void DecodeAlgorithmRc2_40_FixedValue() |
| 73 |
{ |
| 74 |
ContentInfo expectedContentInfo = new ContentInfo(new byte[] { 1, 2, 3, 4 }); |
| 75 |
byte[] encodedMessage = |
| 76 |
("3082011806092A864886F70D010703A0820109308201050201003181CC3081C90201003032301E311C301A0" |
| 77 |
+ "60355040313135253414B65795472616E73666572436170693102105D2FFFF863BABC9B4D3C80AB178A4CCA" |
| 78 |
+ "300D06092A864886F70D010101050004818004E46A48651034B01134B0D4F665C9E85F6C45B58458ECDBAFE" |
| 79 |
+ "B6B55CBFA9AEBEFA52BCBEF3C8811B5118970562623FC35D4B733B55CBC50DA4F49822E1D198834897D3540" |
| 80 |
+ "7B329FECF49277159F2FEAB31173004776B03746381E0DA660B6D656A861E54E79186F36F450105DEB2714D" |
| 81 |
+ "02DB5500921EBE4F1A7D3DFB07E4EE9303106092A864886F70D010701301A06082A864886F70D0302300E02" |
| 82 |
+ "0200A00408D621253C94AF659B800802930ACE6A997122").HexToByteArray(); |
| 83 |
EnvelopedCms ecms = new EnvelopedCms(); |
| 84 |
ecms.Decode(encodedMessage); |
| 85 |
|
| 86 |
AlgorithmIdentifier algorithm = ecms.ContentEncryptionAlgorithm; |
| 87 |
Assert.NotNull(algorithm.Oid); |
| 88 |
Assert.Equal(Oids.Rc2, algorithm.Oid.Value); |
| 89 |
Assert.Equal(40, algorithm.KeyLength); |
| 90 |
} |
| 91 |
|
| 92 |
[Fact] |
| 93 |
[OuterLoop(/* Leaks key on disk if interrupted */)] |
| 94 |
public static void DecodeAlgorithmRc2_40_RoundTrip() |
| 95 |
{ |
| 96 |
ContentInfo contentInfo = new ContentInfo(new byte[] { 1, 2, 3, 4 }); |
| 97 |
EnvelopedCms ecms = new EnvelopedCms(contentInfo, new AlgorithmIdentifier(new Oid(Oids.Rc2), 40)); |
| 98 |
|
| 99 |
using (X509Certificate2 cert = Certificates.RSAKeyTransferCapi1.GetCertificate()) |
| 100 |
{ |
| 101 |
ecms.Encrypt(new CmsRecipient(SubjectIdentifierType.IssuerAndSerialNumber, cert)); |
| 102 |
} |
| 103 |
|
| 104 |
byte[] encodedMessage = ecms.Encode(); |
| 105 |
|
| 106 |
ecms = new EnvelopedCms(); |
| 107 |
ecms.Decode(encodedMessage); |
| 108 |
|
| 109 |
AlgorithmIdentifier algorithm = ecms.ContentEncryptionAlgorithm; |
| 110 |
Assert.NotNull(algorithm.Oid); |
| 111 |
Assert.Equal(Oids.Rc2, algorithm.Oid.Value); |
| 112 |
Assert.Equal(40, algorithm.KeyLength); |
| 113 |
} |
| 114 |
|
| 115 |
[ConditionalFact(nameof(SupportsRc4))] |
| 116 |
[OuterLoop(/* Leaks key on disk if interrupted */)] |
| 117 |
public static void DecodeAlgorithmRc4_40_RoundTrip() |
| 118 |
{ |
| 119 |
ContentInfo contentInfo = new ContentInfo(new byte[] { 1, 2, 3, 4 }); |
| 120 |
EnvelopedCms ecms = new EnvelopedCms(contentInfo, new AlgorithmIdentifier(new Oid(Oids.Rc4), 40)); |
| 121 |
|
| 122 |
using (X509Certificate2 cert = Certificates.RSAKeyTransferCapi1.GetCertificate()) |
| 123 |
{ |
| 124 |
ecms.Encrypt(new CmsRecipient(SubjectIdentifierType.IssuerAndSerialNumber, cert)); |
| 125 |
} |
| 126 |
|
| 127 |
byte[] encodedMessage = ecms.Encode(); |
| 128 |
|
| 129 |
ecms = new EnvelopedCms(); |
| 130 |
ecms.Decode(encodedMessage); |
| 131 |
|
| 132 |
AlgorithmIdentifier algorithm = ecms.ContentEncryptionAlgorithm; |
| 133 |
Assert.NotNull(algorithm.Oid); |
| 134 |
Assert.Equal(Oids.Rc4, algorithm.Oid.Value); |
| 135 |
Assert.Equal(40, algorithm.KeyLength); |
| 136 |
} |
| 137 |
|
| 138 |
|
| 139 |
[ConditionalFact(nameof(DoesNotSupportRc4))] |
| 140 |
[OuterLoop(/* Leaks key on disk if interrupted */)] |
| 141 |
public static void DecodeAlgorithmRc4_40_PlatformNotSupported() |
| 142 |
{ |
| 143 |
ContentInfo contentInfo = new ContentInfo(new byte[] { 1, 2, 3, 4 }); |
| 144 |
EnvelopedCms ecms = new EnvelopedCms(contentInfo, new AlgorithmIdentifier(new Oid(Oids.Rc4), 40)); |
| 145 |
|
| 146 |
using (X509Certificate2 cert = Certificates.RSAKeyTransferCapi1.GetCertificate()) |
| 147 |
{ |
| 148 |
CmsRecipient recipient = new CmsRecipient(SubjectIdentifierType.IssuerAndSerialNumber, cert); |
| 149 |
|
| 150 |
CryptographicException e = |
| 151 |
Assert.Throws<CryptographicException>(() => ecms.Encrypt(recipient)); |
| 152 |
|
| 153 |
Assert.Contains(Oids.Rc4, e.Message); |
| 154 |
} |
| 155 |
} |
| 156 |
|
| 157 |
[Fact] |
| 158 |
public static void DecodeAlgorithmDes_RoundTrip() |
| 159 |
{ |
| 160 |
AlgorithmIdentifier algorithm = new AlgorithmIdentifier(new Oid(Oids.Des)); |
| 161 |
ContentInfo contentInfo = new ContentInfo(new byte[] { 1, 2, 3 }); |
| 162 |
EnvelopedCms ecms = new EnvelopedCms(contentInfo, algorithm); |
| 163 |
using (X509Certificate2 cert = Certificates.RSAKeyTransfer1.GetCertificate()) |
| 164 |
{ |
| 165 |
CmsRecipient cmsRecipient = new CmsRecipient(cert); |
| 166 |
ecms.Encrypt(cmsRecipient); |
| 167 |
} |
| 168 |
byte[] encodedMessage = ecms.Encode(); |
| 169 |
VerifyAlgorithmDes(encodedMessage); |
| 170 |
} |
| 171 |
|
| 172 |
[Fact] |
| 173 |
public static void DecodeAlgorithmDes_FixedValue() |
| 174 |
{ |
| 175 |
byte[] encodedMessage = |
| 176 |
("3082010906092a864886f70d010703a081fb3081f80201003181c83081c5020100302e301a311830160603550403130f5253" |
| 177 |
+ "414b65795472616e7366657231021031d935fb63e8cfab48a0bf7b397b67c0300d06092a864886f70d01010105000481801f" |
| 178 |
+ "0621d0d37f0e89c2eac528c2bf97eff89131aa55f08c286d6c41f403168e74bf49c39d4752830ff2b222b704dbec0a3bb109" |
| 179 |
+ "0f6d39a2abb14819083f0a2c767958ebe19a2b73147306202da9ca483b911a0218ffb4ca3046de322cf3be6c1500af3d6b52" |
| 180 |
+ "f02e3fa5a1a85e3fa035b3df65400fd29d8104d93481a6716c170c302806092a864886f70d010701301106052b0e03020704" |
| 181 |
+ "0880052d38754b7f298008fc778a46c054e572").HexToByteArray(); |
| 182 |
VerifyAlgorithmDes(encodedMessage); |
| 183 |
} |
| 184 |
|
| 185 |
private static void VerifyAlgorithmDes(byte[] encodedMessage) |
| 186 |
{ |
| 187 |
EnvelopedCms ecms = new EnvelopedCms(); |
| 188 |
ecms.Decode(encodedMessage); |
| 189 |
AlgorithmIdentifier algorithm = ecms.ContentEncryptionAlgorithm; |
| 190 |
Assert.NotNull(algorithm.Oid); |
| 191 |
Assert.Equal(Oids.Des, algorithm.Oid.Value); |
| 192 |
Assert.Equal(64, algorithm.KeyLength); |
| 193 |
} |
| 194 |
|
| 195 |
[Fact] |
| 196 |
public static void DecodeAlgorithm3Des_RoundTrip() |
| 197 |
{ |
| 198 |
AlgorithmIdentifier algorithm = new AlgorithmIdentifier(new Oid(Oids.TripleDesCbc)); |
| 199 |
ContentInfo contentInfo = new ContentInfo(new byte[] { 1, 2, 3 }); |
| 200 |
EnvelopedCms ecms = new EnvelopedCms(contentInfo, algorithm); |
| 201 |
using (X509Certificate2 cert = Certificates.RSAKeyTransfer1.GetCertificate()) |
| 202 |
{ |
| 203 |
CmsRecipient cmsRecipient = new CmsRecipient(cert); |
| 204 |
ecms.Encrypt(cmsRecipient); |
| 205 |
} |
| 206 |
byte[] encodedMessage = ecms.Encode(); |
| 207 |
VerifyAlgorithm3Des(encodedMessage); |
| 208 |
} |
| 209 |
|
| 210 |
[Fact] |
| 211 |
public static void DecodeAlgorithm3Des_FixedValue() |
| 212 |
{ |
| 213 |
byte[] encodedMessage = |
| 214 |
("3082010c06092a864886f70d010703a081fe3081fb0201003181c83081c5020100302e301a311830160603550403130f5253" |
| 215 |
+ "414b65795472616e7366657231021031d935fb63e8cfab48a0bf7b397b67c0300d06092a864886f70d010101050004818087" |
| 216 |
+ "77495ce527339dc78b063477104d513eda6f8a7b2f5c642fddf81d86a4c139f836590a1f81efafb953f7c6d666021fe5c031" |
| 217 |
+ "10064f21ce4b17f4737a9370298a8b540b1d597fbc39d21a537b45d9dc65c8d2cbafcc6c7208b5f0453f7ef206f4b1d99cc0" |
| 218 |
+ "7186f7f5b31a0a9ec885296ae27183f51b83a64bb8bf46ece16305302b06092a864886f70d010701301406082a864886f70d" |
| 219 |
+ "03070408d8ac6958c16ea6f58008beb49fa4214d1e3f").HexToByteArray(); VerifyAlgorithm3Des(encodedMessage); |
| 220 |
} |
| 221 |
|
| 222 |
private static void VerifyAlgorithm3Des(byte[] encodedMessage) |
| 223 |
{ |
| 224 |
EnvelopedCms ecms = new EnvelopedCms(); |
| 225 |
ecms.Decode(encodedMessage); |
| 226 |
AlgorithmIdentifier algorithm = ecms.ContentEncryptionAlgorithm; |
| 227 |
Assert.NotNull(algorithm.Oid); |
| 228 |
Assert.Equal(Oids.TripleDesCbc, algorithm.Oid.Value); |
| 229 |
Assert.Equal(192, algorithm.KeyLength); |
| 230 |
} |
| 231 |
|
| 232 |
[ConditionalFact(nameof(SupportsRc4))] |
| 233 |
public static void DecodeAlgorithmRc4_RoundTrip() |
| 234 |
{ |
| 235 |
AlgorithmIdentifier algorithm = new AlgorithmIdentifier(new Oid(Oids.Rc4)); |
| 236 |
ContentInfo contentInfo = new ContentInfo(new byte[] { 1, 2, 3 }); |
| 237 |
EnvelopedCms ecms = new EnvelopedCms(contentInfo, algorithm); |
| 238 |
using (X509Certificate2 cert = Certificates.RSAKeyTransfer1.GetCertificate()) |
| 239 |
{ |
| 240 |
CmsRecipient cmsRecipient = new CmsRecipient(cert); |
| 241 |
ecms.Encrypt(cmsRecipient); |
| 242 |
} |
| 243 |
byte[] encodedMessage = ecms.Encode(); |
| 244 |
VerifyAlgorithmRc4(encodedMessage); |
| 245 |
} |
| 246 |
|
| 247 |
[Fact] |
| 248 |
public static void DecodeAlgorithmRc4_FixedValue() |
| 249 |
{ |
| 250 |
byte[] encodedMessage = |
| 251 |
("3081ff06092a864886f70d010703a081f13081ee0201003181c83081c5020100302e301a311830160603550403130f525341" |
| 252 |
+ "4b65795472616e7366657231021031d935fb63e8cfab48a0bf7b397b67c0300d06092a864886f70d010101050004818036ce" |
| 253 |
+ "a9d8c17763ceffa0c4902da6e02a2168349eba10c66f827fb427c944d035c0cea65a7729131527b38b1c5e0b378205bb571a" |
| 254 |
+ "c94ea26e2b4e8ab9b53d5ec7fec48a095d1145769878e6b2947adf41ad924004b185914bed859b2be7e84bbdb59b45663c2c" |
| 255 |
+ "56392895c0534766e743b70db12cd08377c35d9cdf21ac7eb4a4301e06092a864886f70d010701300c06082a864886f70d03" |
| 256 |
+ "04050080030039bd").HexToByteArray(); |
| 257 |
VerifyAlgorithmRc4(encodedMessage); |
| 258 |
} |
| 259 |
|
| 260 |
private static void VerifyAlgorithmRc4(byte[] encodedMessage) |
| 261 |
{ |
| 262 |
EnvelopedCms ecms = new EnvelopedCms(); |
| 263 |
ecms.Decode(encodedMessage); |
| 264 |
AlgorithmIdentifier algorithm = ecms.ContentEncryptionAlgorithm; |
| 265 |
Assert.NotNull(algorithm.Oid); |
| 266 |
Assert.Equal(Oids.Rc4, algorithm.Oid.Value); |
| 267 |
Assert.Equal(128, algorithm.KeyLength); |
| 268 |
} |
| 269 |
|
| 270 |
[Fact] |
| 271 |
public static void DecodeAlgorithmRc4_40_FixedValue() |
| 272 |
{ |
| 273 |
byte[] encodedMessage = |
| 274 |
("3082011006092A864886F70D010703A08201013081FE0201003181CC3081C90201003032301E311C301A060" |
| 275 |
+ "355040313135253414B65795472616E73666572436170693102105D2FFFF863BABC9B4D3C80AB178A4CCA30" |
| 276 |
+ "0D06092A864886F70D01010105000481809D242C1517B82A58335E0337B0B2CE97B2789AF31A6B31311417B" |
| 277 |
+ "A069D0D76FD08AE5B4F58C290116667FFD00319AA7AFED4EEAD9D5031C0D17A48E6CB39A5EB62C8BD7F4C2C" |
| 278 |
+ "BE8E581EF8B7FF7BA9376923A367B9B7E031F630E4CA6ADCB31209B04B03E64076FB0465E7E437B13D4AEA2" |
| 279 |
+ "70CA89EB58C1A598F0AC88DCB4024302A06092A864886F70D010701301706082A864886F70D0304040B4B5A" |
| 280 |
+ "8F64D714F933642D4A8004C68A936F").HexToByteArray(); |
| 281 |
|
| 282 |
EnvelopedCms ecms = new EnvelopedCms(); |
| 283 |
ecms.Decode(encodedMessage); |
| 284 |
AlgorithmIdentifier algorithm = ecms.ContentEncryptionAlgorithm; |
| 285 |
Assert.NotNull(algorithm.Oid); |
| 286 |
Assert.Equal(Oids.Rc4, algorithm.Oid.Value); |
| 287 |
Assert.Equal(40, algorithm.KeyLength); |
| 288 |
} |
| 289 |
|
| 290 |
[Fact] |
| 291 |
public static void EncryptionAlgorithmAes128_IgnoresKeyLength() |
| 292 |
{ |
| 293 |
// For desktop compat, static key length ciphers ignore the key lengths supplied |
| 294 |
AlgorithmIdentifier algorithm = new AlgorithmIdentifier(new Oid(Oids.Aes128), 3); |
| 295 |
ContentInfo contentInfo = new ContentInfo(new byte[] { 1, 2, 3 }); |
| 296 |
EnvelopedCms ecms = new EnvelopedCms(contentInfo, algorithm); |
| 297 |
using (X509Certificate2 cert = Certificates.RSAKeyTransfer1.GetCertificate()) |
| 298 |
{ |
| 299 |
CmsRecipient cmsRecipient = new CmsRecipient(cert); |
| 300 |
ecms.Encrypt(cmsRecipient); |
| 301 |
} |
| 302 |
byte[] encodedMessage = ecms.Encode(); |
| 303 |
|
| 304 |
ecms.Decode(encodedMessage); |
| 305 |
|
| 306 |
Assert.Equal(Oids.Aes128, ecms.ContentEncryptionAlgorithm.Oid.Value); |
| 307 |
Assert.Equal(0, ecms.ContentEncryptionAlgorithm.KeyLength); |
| 308 |
} |
| 309 |
|
| 310 |
[Fact] |
| 311 |
public static void DecodeAlgorithmAes128_RoundTrip() |
| 312 |
{ |
| 313 |
AlgorithmIdentifier algorithm = new AlgorithmIdentifier(new Oid(Oids.Aes128)); |
| 314 |
ContentInfo contentInfo = new ContentInfo(new byte[] { 1, 2, 3 }); |
| 315 |
EnvelopedCms ecms = new EnvelopedCms(contentInfo, algorithm); |
| 316 |
using (X509Certificate2 cert = Certificates.RSAKeyTransfer1.GetCertificate()) |
| 317 |
{ |
| 318 |
CmsRecipient cmsRecipient = new CmsRecipient(cert); |
| 319 |
ecms.Encrypt(cmsRecipient); |
| 320 |
} |
| 321 |
byte[] encodedMessage = ecms.Encode(); |
| 322 |
VerifyAlgorithmAes128(encodedMessage); |
| 323 |
} |
| 324 |
|
| 325 |
[Fact] |
| 326 |
public static void DecodeAlgorithmAes128_FixedValue() |
| 327 |
{ |
| 328 |
byte[] encodedMessage = |
| 329 |
("3082011f06092a864886f70d010703a08201103082010c0201003181c83081c5020100302e301a311830160603550403130f" |
| 330 |
+ "5253414b65795472616e7366657231021031d935fb63e8cfab48a0bf7b397b67c0300d06092a864886f70d01010105000481" |
| 331 |
+ "8011e777f410a2c2ab5152303dc011da5bfc5982f2254040ed00bdcfaa028a14624fb63c817082d6e373b4cdbbcce3ab5dee" |
| 332 |
+ "bf85c33cea8ffa40b31a784b61dde7eab3736261f0d912b829773201bdf6cb93a602127a30cad5fa1b3034ba10cd4fddcfe5" |
| 333 |
+ "f30bb05ffc2171b18d3200ef21bda8631a4b82af603277db7ebb752999303c06092a864886f70d010701301d060960864801" |
| 334 |
+ "65030401020410d38e15cc9b02555ae95a75e5a7af86e98010c000f2c29b88ec5e4e6ba51159abae55").HexToByteArray(); |
| 335 |
VerifyAlgorithmAes128(encodedMessage); |
| 336 |
} |
| 337 |
|
| 338 |
private static void VerifyAlgorithmAes128(byte[] encodedMessage) |
| 339 |
{ |
| 340 |
EnvelopedCms ecms = new EnvelopedCms(); |
| 341 |
ecms.Decode(encodedMessage); |
| 342 |
AlgorithmIdentifier algorithm = ecms.ContentEncryptionAlgorithm; |
| 343 |
Assert.NotNull(algorithm.Oid); |
| 344 |
Assert.Equal(Oids.Aes128, algorithm.Oid.Value); |
| 345 |
Assert.Equal(0, algorithm.KeyLength); |
| 346 |
} |
| 347 |
|
| 348 |
[Fact] |
| 349 |
public static void DecodeAlgorithmAes192_RoundTrip() |
| 350 |
{ |
| 351 |
AlgorithmIdentifier algorithm = new AlgorithmIdentifier(new Oid(Oids.Aes192)); |
| 352 |
ContentInfo contentInfo = new ContentInfo(new byte[] { 1, 2, 3 }); |
| 353 |
EnvelopedCms ecms = new EnvelopedCms(contentInfo, algorithm); |
| 354 |
using (X509Certificate2 cert = Certificates.RSAKeyTransfer1.GetCertificate()) |
| 355 |
{ |
| 356 |
CmsRecipient cmsRecipient = new CmsRecipient(cert); |
| 357 |
ecms.Encrypt(cmsRecipient); |
| 358 |
} |
| 359 |
byte[] encodedMessage = ecms.Encode(); |
| 360 |
VerifyAlgorithmAes192(encodedMessage); |
| 361 |
} |
| 362 |
|
| 363 |
[Fact] |
| 364 |
public static void DecodeAlgorithmAes192_FixedValue() |
| 365 |
{ |
| 366 |
byte[] encodedMessage = |
| 367 |
("3082011f06092a864886f70d010703a08201103082010c0201003181c83081c5020100302e301a311830160603550403130f" |
| 368 |
+ "5253414b65795472616e7366657231021031d935fb63e8cfab48a0bf7b397b67c0300d06092a864886f70d01010105000481" |
| 369 |
+ "8095870ef593f7234a6a12fc23f6dacd75d6e5a5ee05077b7390632c0beb2689a3dd587757e976992ffd26f6dd374fb64f47" |
| 370 |
+ "6eb4d920a55d735935716671bc12dc65b84c29c5a72aa78a4480e19a28ac09395e708e99e1e9e9704ee4d077541bfed1d06d" |
| 371 |
+ "32f3a7e9441fde9133858a0e825af04a36b5943e0f39eade1463de7c12303c06092a864886f70d010701301d060960864801" |
| 372 |
+ "65030401160410d217d9a8bb30516d54aab00a5e6089b68010149eec8997deedcbad000ae6c1a7fb9d").HexToByteArray(); |
| 373 |
VerifyAlgorithmAes192(encodedMessage); |
| 374 |
} |
| 375 |
|
| 376 |
private static void VerifyAlgorithmAes192(byte[] encodedMessage) |
| 377 |
{ |
| 378 |
EnvelopedCms ecms = new EnvelopedCms(); |
| 379 |
ecms.Decode(encodedMessage); |
| 380 |
AlgorithmIdentifier algorithm = ecms.ContentEncryptionAlgorithm; |
| 381 |
Assert.NotNull(algorithm.Oid); |
| 382 |
Assert.Equal(Oids.Aes192, algorithm.Oid.Value); |
| 383 |
Assert.Equal(0, algorithm.KeyLength); |
| 384 |
} |
| 385 |
|
| 386 |
[Fact] |
| 387 |
public static void DecodeAlgorithmAes256_RoundTrip() |
| 388 |
{ |
| 389 |
AlgorithmIdentifier algorithm = new AlgorithmIdentifier(new Oid(Oids.Aes256)); |
| 390 |
ContentInfo contentInfo = new ContentInfo(new byte[] { 1, 2, 3 }); |
| 391 |
EnvelopedCms ecms = new EnvelopedCms(contentInfo, algorithm); |
| 392 |
using (X509Certificate2 cert = Certificates.RSAKeyTransfer1.GetCertificate()) |
| 393 |
{ |
| 394 |
CmsRecipient cmsRecipient = new CmsRecipient(cert); |
| 395 |
ecms.Encrypt(cmsRecipient); |
| 396 |
} |
| 397 |
byte[] encodedMessage = ecms.Encode(); |
| 398 |
VerifyAlgorithmAes256(encodedMessage); |
| 399 |
} |
| 400 |
|
| 401 |
[Fact] |
| 402 |
public static void DecodeAlgorithmAes256_FixedValue() |
| 403 |
{ |
| 404 |
byte[] encodedMessage = |
| 405 |
("3082011f06092a864886f70d010703a08201103082010c0201003181c83081c5020100302e301a311830160603550403130f" |
| 406 |
+ "5253414b65795472616e7366657231021031d935fb63e8cfab48a0bf7b397b67c0300d06092a864886f70d01010105000481" |
| 407 |
+ "809605c24f3bc99b3437f3e12e44c3a49c91ca0dc94a473fc21388a0f1c69486befa97eb7b9a96e2a9309f89612ad108d1c7" |
| 408 |
+ "2db6cc66426253e639939b9be852df9212fba9bb52f857a39a26c04a20bae7b7620a1e53873a7ef03c4139edc7a50ee297ea" |
| 409 |
+ "fdc1372596ef299e71b6d4db146cad48a8485e17b3604a56958afdbe83303c06092a864886f70d010701301d060960864801" |
| 410 |
+ "650304012a04100b85a6899050456469102f41aaa685158010b3008bd0eb863574ecbe46a5cc91a99c").HexToByteArray(); |
| 411 |
|
| 412 |
VerifyAlgorithmAes256(encodedMessage); |
| 413 |
} |
| 414 |
|
| 415 |
private static void VerifyAlgorithmAes256(byte[] encodedMessage) |
| 416 |
{ |
| 417 |
EnvelopedCms ecms = new EnvelopedCms(); |
| 418 |
ecms.Decode(encodedMessage); |
| 419 |
AlgorithmIdentifier algorithm = ecms.ContentEncryptionAlgorithm; |
| 420 |
Assert.NotNull(algorithm.Oid); |
| 421 |
Assert.Equal(Oids.Aes256, algorithm.Oid.Value); |
| 422 |
Assert.Equal(0, algorithm.KeyLength); |
| 423 |
} |
| 424 |
} |
| 425 |
} |
| 426 |
|
| 427 |
|