-
Notifications
You must be signed in to change notification settings - Fork 4.6k
/
InvalidUsageTests.cs
79 lines (70 loc) · 3.33 KB
/
InvalidUsageTests.cs
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
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.IO;
using Xunit;
namespace System.Security.Cryptography.Tests
{
public class InvalidUsageTests
{
[Fact]
public void InvalidHashCoreArgumentsFromDerivedType()
{
using (var hmac = new DerivedHMACSHA1())
{
Assert.Throws<ArgumentNullException>(() => hmac.ExposedHashCore(null, 0, 0));
AssertExtensions.Throws<ArgumentOutOfRangeException>("offset", "inputOffset", () => hmac.ExposedHashCore(new byte[1], -1, 1));
AssertExtensions.Throws<ArgumentOutOfRangeException, ArgumentException>("count", null, () => hmac.ExposedHashCore(new byte[1], 0, -1));
AssertExtensions.Throws<ArgumentException>(null, () => hmac.ExposedHashCore(new byte[1], 0, 2));
AssertExtensions.Throws<ArgumentException>(null, () => hmac.ExposedHashCore(new byte[2], 1, 2));
AssertExtensions.Throws<ArgumentException>(null, () => hmac.ExposedHashCore(new byte[1], int.MaxValue, int.MaxValue));
}
}
[Fact]
public void InvalidHashCoreArgumentsFromStream()
{
using (SHA1 sha1 = SHA1.Create())
{
AssertExtensions.Throws<ArgumentException>(null, () => sha1.ComputeHash(new BadReadStream(BadReadStream.ErrorCondition.TooLargeValueFromRead)));
sha1.ComputeHash(new BadReadStream(BadReadStream.ErrorCondition.NegativeValueFromRead));
}
}
private sealed class DerivedHMACSHA1 : HMACSHA1
{
public void ExposedHashCore(byte[] rgb, int ib, int cb)
{
HashCore(rgb, ib, cb);
}
}
private sealed class BadReadStream : Stream
{
internal enum ErrorCondition
{
NegativeValueFromRead,
TooLargeValueFromRead
}
private readonly ErrorCondition _condition;
public BadReadStream(ErrorCondition condition)
{
_condition = condition;
}
public override int Read(byte[] buffer, int offset, int count)
{
switch (_condition)
{
case ErrorCondition.NegativeValueFromRead: return -1;
case ErrorCondition.TooLargeValueFromRead: return buffer.Length + 1;
default: return 0;
}
}
public override bool CanRead { get { return true; } }
public override bool CanSeek { get { return false; } }
public override bool CanWrite { get { return false; } }
public override long Length { get { throw new NotSupportedException(); } }
public override long Position { get { throw new NotSupportedException(); } set { throw new NotSupportedException(); } }
public override void Flush() { }
public override long Seek(long offset, SeekOrigin origin) { throw new NotSupportedException(); }
public override void SetLength(long value) { throw new NotSupportedException(); }
public override void Write(byte[] buffer, int offset, int count) { throw new NotSupportedException(); }
}
}
}