public void round_trip_query_should_validate()
{
Signature signature = new HS256Signature(_symmetricKey);
var payload = new EncodingParameters("token");
payload.QueryParameters.Add(new KeyValuePair <string, string>("x", "1"));
payload.QueryParameters.Add(new KeyValuePair <string, string>("y", "2"));
var token = signature.Sign(payload);
var cnfJson = new Cnf(
new JsonWebKey
{
Kty = "oct",
Alg = "HS256",
K = Base64Url.Encode(_symmetricKey)
}).ToJson();
var jwk = CnfParser.Parse(cnfJson);
var key = jwk.ToPublicKey();
signature = key.ToSignature();
var result = signature.Verify(token);
result.Should().NotBeNull();
payload.Encode().IsSame(result).Should().BeTrue();
}
public async Task access_token_in_pop_token_should_be_validated()
{
var claims = new Claim[] {
new Claim("sub", "123")
};
var id = new ClaimsIdentity(claims, "password");
var subject = new ClaimsPrincipal(id);
var handler = new JwtSecurityTokenHandler();
var token = new JwtSecurityToken(
"issuer", "audience",
subject.Claims,
notBefore: DateTime.UtcNow.AddSeconds(-5),
expires: DateTime.UtcNow.AddMinutes(5),
signingCredentials: new X509SigningCredentials(SigningCertificate.Cert));
var jwt = handler.WriteToken(token);
var encodingParams = new EncodingParameters(jwt);
var pop = _signature.Sign(encodingParams);
_client.SetToken("PoP", pop);
var response = await _client.GetAsync("http://foo.com/path?x=1&y=2");
response.StatusCode.Should().Be(HttpStatusCode.OK);
}
public int StartCapture(string pwszFileName, Guid subType)
{
var hr = 0;
lock (LockSync)
{
if (PReader == null)
return hr;
// Create the sink writer
if (Succeeded(hr))
{
hr = MFExtern.MFCreateSinkWriterFromURL(pwszFileName, null, null, out PWriter);
}
// Set up the encoding parameters.
if (Succeeded(hr))
{
var param = new EncodingParameters {Subtype = subType};
hr = ConfigureCapture(param);
}
if (Succeeded(hr))
{
BFirstSample = true;
LlBaseTime = 0;
}
}
return hr;
}
public virtual async Task <EncodedParameters> ReadEncodedParametersAsync(IDictionary <string, object> env, EncodedParameters popValues)
{
if (env == null)
{
throw new ArgumentNullException("env");
}
if (popValues == null)
{
throw new ArgumentNullException("popValues");
}
var logger = Logging.GetLogger();
var ctx = new OwinContext(env);
var parameters = new EncodingParameters(popValues.AccessToken);
if (ValidateMethod)
{
logger.WriteVerbose("Validating method");
parameters.Method = new HttpMethod(ctx.Request.Method);
}
if (ValidateHost)
{
logger.WriteVerbose("Validating host");
parameters.Host = ctx.Request.Host.Value;
}
if (ValidatePath)
{
logger.WriteVerbose("Validating path");
parameters.Path = ctx.Request.Uri.AbsolutePath;
}
var queryParamsToValidate = GetQueryParamsToValidate(ctx.Request.Query, popValues.QueryParameters?.Keys);
foreach (var item in queryParamsToValidate)
{
logger.WriteVerbose("Validating query string parameter: " + item.Key);
parameters.QueryParameters.Add(item);
}
var headersToValidate = GetRequestHeadersToValidate(ctx.Request.Headers, popValues.RequestHeaders?.Keys);
foreach (var item in headersToValidate)
{
logger.WriteVerbose("Validating request header: " + item.Key);
parameters.RequestHeaders.Add(item);
}
if (ValidateBody)
{
logger.WriteVerbose("Validating body");
parameters.Body = await ReadBodyAsync(ctx.Request);
}
return(parameters.Encode());
}
HResult ConfigureEncoder(
EncodingParameters eparams,
IMFMediaType pType,
IMFSinkWriter pWriter,
out int pdwStreamIndex
)
{
HResult hr = HResult.S_OK;
IMFMediaType pType2 = null;
hr = MFExtern.MFCreateMediaType(out pType2);
if (Succeeded(hr))
{
hr = pType2.SetGUID(MFAttributesClsid.MF_MT_MAJOR_TYPE, MFMediaType.Video);
}
if (Succeeded(hr))
{
hr = pType2.SetGUID(MFAttributesClsid.MF_MT_SUBTYPE, eparams.subtype);
}
if (Succeeded(hr))
{
hr = pType2.SetUINT32(MFAttributesClsid.MF_MT_AVG_BITRATE, eparams.bitrate);
}
if (Succeeded(hr))
{
hr = CopyAttribute(pType, pType2, MFAttributesClsid.MF_MT_FRAME_SIZE);
}
if (Succeeded(hr))
{
hr = CopyAttribute(pType, pType2, MFAttributesClsid.MF_MT_FRAME_RATE);
}
if (Succeeded(hr))
{
hr = CopyAttribute(pType, pType2, MFAttributesClsid.MF_MT_PIXEL_ASPECT_RATIO);
}
if (Succeeded(hr))
{
hr = CopyAttribute(pType, pType2, MFAttributesClsid.MF_MT_INTERLACE_MODE);
}
pdwStreamIndex = 0;
if (Succeeded(hr))
{
hr = pWriter.AddStream(pType2, out pdwStreamIndex);
}
SafeRelease(pType2);
return(hr);
}
public void asymmetric_signed_result_should_be_able_to_verifed()
{
var subject = new RS256Signature(_asymmetricKey);
var encoding = new EncodingParameters("foo");
var token = subject.Sign(encoding);
var decoded = subject.Verify(token);
decoded.AccessToken.Should().Be("foo");
}
public void encode_should_capture_path()
{
var subject = new EncodingParameters("token");
subject.Path = "/path";
var result = subject.Encode();
result.Path.Should().Be("/path");
}
public void encode_should_capture_host()
{
var subject = new EncodingParameters("token");
subject.Host = "foo.com";
var result = subject.Encode();
result.Host.Should().Be("foo.com");
}
public void encode_should_capture_method()
{
var subject = new EncodingParameters("token");
subject.Method = HttpMethod.Put;
var result = subject.Encode();
result.Method.Should().Be("PUT");
}
public void when_using_wrong_key_should_not_be_able_to_verify()
{
var encoding = new EncodingParameters("foo");
var token = new RS256Signature(_asymmetricKey).Sign(encoding);
var subject = new HS256Signature(_symmetricKey);
var decoded = subject.Verify(token);
decoded.Should().BeNull();
}
public void encode_should_capture_body()
{
var subject = new EncodingParameters("token");
subject.Body = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
var result = subject.Encode();
result.BodyHash.Should().Be("vnPfBFvKBXMv9S6m1FMSeSi1VLnnmqYXGr4xk9ImCp8");
}
HResult ConfigureCapture(EncodingParameters eparam)
{
HResult hr = HResult.S_OK;
int sink_stream = 0;
IMFMediaType pType = null;
hr = ConfigureSourceReader(m_pReader);
if (Succeeded(hr))
{
hr = m_pReader.GetCurrentMediaType(
MF_SOURCE_READER_FIRST_VIDEO_STREAM,
out pType
);
}
if (Succeeded(hr))
{
hr = ConfigureEncoder(eparam, pType, m_pWriter, out sink_stream);
}
if (Succeeded(hr))
{
// Register the color converter DSP for this process, in the video
// processor category. This will enable the sink writer to enumerate
// the color converter when the sink writer attempts to match the
// media types.
hr = MFExtern.MFTRegisterLocalByCLSID(
typeof(CColorConvertDMO).GUID,
MFTransformCategory.MFT_CATEGORY_VIDEO_PROCESSOR,
"",
MFT_EnumFlag.SyncMFT,
0,
null,
0,
null
);
}
if (Succeeded(hr))
{
hr = m_pWriter.SetInputMediaType(sink_stream, pType, null);
}
if (Succeeded(hr))
{
hr = m_pWriter.BeginWriting();
}
SafeRelease(pType);
return(hr);
}
public void encode_should_capture_query()
{
var subject = new EncodingParameters("token");
subject.QueryParameters.Add(new KeyValuePair <string, string>("foo", "bar1"));
subject.QueryParameters.Add(new KeyValuePair <string, string>("foo", "bar2"));
var result = subject.Encode();
result.QueryParameters.Should().NotBeNull();
result.QueryParameters.Keys.Should().ContainInOrder(new string[] { "foo", "foo" });
result.QueryParameters.HashedValue.Should().Be("EgePUeakH8URmSH3yz8zE39c0r4kYVYsuQRSZa_MdvQ");
}
public void encode_should_capture_headers()
{
var subject = new EncodingParameters("token");
subject.RequestHeaders.Add(new KeyValuePair <string, string>("foo", "bar1"));
subject.RequestHeaders.Add(new KeyValuePair <string, string>("foo", "bar2"));
var result = subject.Encode();
result.RequestHeaders.Should().NotBeNull();
result.RequestHeaders.Keys.Should().ContainInOrder(new string[] { "foo", "foo" });
result.RequestHeaders.HashedValue.Should().Be("trcKLrzChz2G8_T50KpExyZ9DTfcsMTXsGGd3YwftLc");
}
public TextFileUserImporter(Stream stream, FileParameters param)
{
this.stream = stream;
ExcludeList = new List <string> {
"ID", "Status"
};
Encoding = EncodingParameters.GetById(param.Encode);
Separators = SeparatorParameters.GetById(param.Separator);
TextDelmiter = DelimiterParameters.GetById(param.Delimiter);
FirstPosition = param.Position;
UserHeader = param.UserHeader;
}
public async Task valid_claim_should_succeed_validation()
{
_stubAuthenticationManager.Identity = _cnfIdentity;
var token = new Dictionary <string, object>
{
{ "at", "token" }
};
var payload = new EncodingParameters("token");
var popToken = _signature.Sign(payload);
var result = await DefaultPopSignatureValidator.ValidateTokenAsync(_context.Environment, _stubOptions, popToken);
result.Should().BeTrue();
}
public async Task negative_timestamp_should_fail_validation()
{
_stubAuthenticationManager.Identity = _cnfIdentity;
var token = new Dictionary <string, object>
{
{ "at", "token" }
};
var payload = new EncodingParameters("token");
payload.TimeStamp = DateTimeOffset.MinValue;
var popToken = _signature.Sign(payload);
var result = await DefaultPopSignatureValidator.ValidateTokenAsync(_context.Environment, _stubOptions, popToken);
result.Should().BeFalse();
}
public async Task too_new_timestamp_should_fail_validation()
{
_stubOptions.TimespanValidityWindow = TimeSpan.FromSeconds(300);
_stubAuthenticationManager.Identity = _cnfIdentity;
var token = new Dictionary <string, object>
{
{ "at", "token" }
};
var payload = new EncodingParameters("token");
payload.TimeStamp = DateTimeOffset.UtcNow.AddSeconds(302);
var popToken = _signature.Sign(payload);
var result = await DefaultPopSignatureValidator.ValidateTokenAsync(_context.Environment, _stubOptions, popToken);
result.Should().BeFalse();
}
public void encode_should_capture_access_token_and_timestamp()
{
var subject = new EncodingParameters("token");
subject.AccessToken.Should().Be("token");
var now = DateTimeOffset.UtcNow;
subject.TimeStamp = now;
var result = subject.Encode();
result.AccessToken.Should().Be("token");
result.TimeStamp.Should().Be(now.ToEpochTime());
result.Method.Should().BeNull();
result.Host.Should().BeNull();
result.Path.Should().BeNull();
result.QueryParameters.Should().BeNull();
result.RequestHeaders.Should().BeNull();
result.BodyHash.Should().BeNull();
}
public void alg_mismatch_should_fail_validation()
{
var hs256 = new HS256Signature(_symmetricKey);
var hs384 = new HS384Signature(_symmetricKey);
var hs512 = new HS512Signature(_symmetricKey);
var rs256 = new RS256Signature(_asymmetricKey);
var rs384 = new RS384Signature(_asymmetricKey);
var rs512 = new RS512Signature(_asymmetricKey);
var encoding = new EncodingParameters("foo");
hs256.Verify(hs384.Sign(encoding)).Should().BeNull();
hs384.Verify(hs512.Sign(encoding)).Should().BeNull();
hs512.Verify(hs256.Sign(encoding)).Should().BeNull();
rs256.Verify(rs512.Sign(encoding)).Should().BeNull();
rs384.Verify(rs256.Sign(encoding)).Should().BeNull();
rs512.Verify(rs384.Sign(encoding)).Should().BeNull();
rs512.Verify(hs512.Sign(encoding)).Should().BeNull();
hs512.Verify(rs512.Sign(encoding)).Should().BeNull();
}
public HResult StartCapture(
IMFActivate pActivate,
string pwszFileName,
EncodingParameters param
)
{
HResult hr = HResult.S_OK;
IMFMediaSource pSource = null;
object pS;
lock (this)
{
// Create the media source for the device.
hr = pActivate.ActivateObject(
typeof(IMFMediaSource).GUID,
out pS
);
pSource = (IMFMediaSource)pS;
// Get the symbolic link. This is needed to handle device-
// loss notifications. (See CheckDeviceLost.)
if (Succeeded(hr))
{
int iSize;
hr = pActivate.GetAllocatedString(
MFAttributesClsid.MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK,
out m_pwszSymbolicLink,
out iSize
);
}
if (Succeeded(hr))
{
hr = OpenMediaSource(pSource);
}
// Create the sink writer
if (Succeeded(hr))
{
hr = MFExtern.MFCreateSinkWriterFromURL(
pwszFileName,
null,
null,
out m_pWriter
);
}
// Set up the encoding parameters.
if (Succeeded(hr))
{
hr = ConfigureCapture(param);
}
if (Succeeded(hr))
{
m_bFirstSample = true;
m_llBaseTime = 0;
// Request the first video frame.
hr = m_pReader.ReadSample(
MF_SOURCE_READER_FIRST_VIDEO_STREAM,
0,
IntPtr.Zero,
IntPtr.Zero,
IntPtr.Zero,
IntPtr.Zero
);
}
SafeRelease(pSource);
}
return(hr);
}
public int StartCapture(
IMFActivate pActivate,
string pwszFileName,
EncodingParameters param
)
{
int hr = S_Ok;
IMFMediaSource pSource = null;
object pS;
lock (this)
{
// Create the media source for the device.
hr = pActivate.ActivateObject(
typeof(IMFMediaSource).GUID,
out pS
);
pSource = (IMFMediaSource)pS;
// Get the symbolic link. This is needed to handle device-
// loss notifications. (See CheckDeviceLost.)
if (Succeeded(hr))
{
int iSize;
hr = pActivate.GetAllocatedString(
MFAttributesClsid.MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK,
out m_pwszSymbolicLink,
out iSize
);
}
if (Succeeded(hr))
{
hr = OpenMediaSource(pSource);
}
// Create the sink writer
if (Succeeded(hr))
{
hr = MFExtern.MFCreateSinkWriterFromURL(
pwszFileName,
null,
null,
out m_pWriter
);
}
// Set up the encoding parameters.
if (Succeeded(hr))
{
hr = ConfigureCapture(param);
}
if (Succeeded(hr))
{
m_bFirstSample = true;
m_llBaseTime = 0;
// Request the first video frame.
hr = m_pReader.ReadSample(
MF_SOURCE_READER_FIRST_VIDEO_STREAM,
0,
IntPtr.Zero,
IntPtr.Zero,
IntPtr.Zero,
IntPtr.Zero
);
}
SafeRelease(pSource);
}
return hr;
}
int ConfigureCapture(EncodingParameters eparam)
{
int hr = S_Ok;
int sink_stream = 0;
IMFMediaType pType = null;
hr = ConfigureSourceReader(m_pReader);
if (Succeeded(hr))
{
hr = m_pReader.GetCurrentMediaType(
MF_SOURCE_READER_FIRST_VIDEO_STREAM,
out pType
);
}
if (Succeeded(hr))
{
hr = ConfigureEncoder(eparam, pType, m_pWriter, out sink_stream);
}
if (Succeeded(hr))
{
// Register the color converter DSP for this process, in the video
// processor category. This will enable the sink writer to enumerate
// the color converter when the sink writer attempts to match the
// media types.
hr = MFExtern.MFTRegisterLocalByCLSID(
typeof(CColorConvertDMO).GUID,
MFTransformCategory.MFT_CATEGORY_VIDEO_PROCESSOR,
"",
MFT_EnumFlag.SyncMFT,
0,
null,
0,
null
);
}
if (Succeeded(hr))
{
hr = m_pWriter.SetInputMediaType(sink_stream, pType, null);
}
if (Succeeded(hr))
{
hr = m_pWriter.BeginWriting();
}
SafeRelease(pType);
return hr;
}
private int ConfigureCapture(EncodingParameters eparam)
{
IMFMediaType pType = null;
//var hr = ConfigureSourceReader(PReader);
var hr = PReader.GetCurrentMediaType((int)MF_SOURCE_READER.FirstVideoStream, out pType);
int w, h;
MfGetAttributeSize(pType, out w, out h);
eparam.Bitrate = w*h*20;
var sinkStream = 0;
if (Succeeded(hr))
{
hr = ConfigureEncoder(eparam, pType, PWriter, out sinkStream);
}
if (Succeeded(hr))
{
// Register the color converter DSP for this process, in the video
// processor category. This will enable the sink writer to enumerate
// the color converter when the sink writer attempts to match the
// media types.
hr = MFExtern.MFTRegisterLocalByCLSID(
typeof(CColorConvertDMO).GUID,
MFTransformCategory.MFT_CATEGORY_VIDEO_PROCESSOR,
"",
MFT_EnumFlag.SyncMFT,
0,
null,
0,
null
);
}
if (Succeeded(hr))
{
hr = PWriter.SetInputMediaType(sinkStream, pType, null);
}
if (Succeeded(hr))
{
hr = PWriter.BeginWriting();
}
SafeRelease(pType);
return hr;
}
private static int ConfigureEncoder(EncodingParameters eparams, IMFMediaType pType, IMFSinkWriter pWriter,
out int pdwStreamIndex)
{
IMFMediaType pType2;
var hr = MFExtern.MFCreateMediaType(out pType2);
if (Succeeded(hr))
{
hr = pType2.SetGUID(MFAttributesClsid.MF_MT_MAJOR_TYPE, MFMediaType.Video);
}
if (Succeeded(hr))
{
hr = pType2.SetGUID(MFAttributesClsid.MF_MT_SUBTYPE, eparams.Subtype);
}
if (Succeeded(hr))
{
hr = pType2.SetUINT32(MFAttributesClsid.MF_MT_AVG_BITRATE, eparams.Bitrate);
}
if (Succeeded(hr))
{
hr = CopyAttribute(pType, pType2, MFAttributesClsid.MF_MT_FRAME_SIZE);
}
if (Succeeded(hr))
{
hr = CopyAttribute(pType, pType2, MFAttributesClsid.MF_MT_FRAME_RATE);
}
if (Succeeded(hr))
{
hr = CopyAttribute(pType, pType2, MFAttributesClsid.MF_MT_PIXEL_ASPECT_RATIO);
}
if (Succeeded(hr))
{
hr = CopyAttribute(pType, pType2, MFAttributesClsid.MF_MT_INTERLACE_MODE);
}
pdwStreamIndex = 0;
if (Succeeded(hr))
{
hr = pWriter.AddStream(pType2, out pdwStreamIndex);
}
SafeRelease(pType2);
return hr;
}
