school-cheating/SEBPatch
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 5 Wiki Activity

Restore SEBPatch

Browse Source
This commit is contained in:
Vichingo455
2025-06-01 11:44:20 +02:00
commit 8c656e3137
1297 changed files with 142172 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
SafeExamBrowser.Proctoring/ScreenProctoring/Service/Requests/ContentType.cs Normal file
View File

@@ -0,0 +1,17 @@
/*
* Copyright (c) 2024 ETH Zürich, IT Services
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
namespace SafeExamBrowser.Proctoring.ScreenProctoring.Service.Requests
{
internal static class ContentType
{
internal const string JSON = "application/json;charset=UTF-8";
internal const string OCTET_STREAM = "application/octet-stream";
internal const string URL_ENCODED = "application/x-www-form-urlencoded";
}
}

36
SafeExamBrowser.Proctoring/ScreenProctoring/Service/Requests/CreateSessionRequest.cs Normal file
View File

@@ -0,0 +1,36 @@
/*
* Copyright (c) 2024 ETH Zürich, IT Services
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
using System.Net.Http;
using SafeExamBrowser.Logging.Contracts;
namespace SafeExamBrowser.Proctoring.ScreenProctoring.Service.Requests
{
internal class CreateSessionRequest : Request
{
internal CreateSessionRequest(Api api, HttpClient httpClient, ILogger logger, Parser parser) : base(api, httpClient, logger, parser)
{
}
internal bool TryExecute(string groupId, out string message, out string sessionId)
{
var group = (Header.GROUP_ID, groupId);
var success = TryExecute(HttpMethod.Post, api.SessionEndpoint, out var response, string.Empty, ContentType.URL_ENCODED, Authorization, group);
message = response.ToLogString();
sessionId = default;
if (success)
{
parser.TryParseSessionId(response, out sessionId);
}
return success;
}
}
}

40
SafeExamBrowser.Proctoring/ScreenProctoring/Service/Requests/Extensions.cs Normal file
View File

@@ -0,0 +1,40 @@
/*
* Copyright (c) 2024 ETH Zürich, IT Services
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
using System;
using System.Net.Http;
using System.Text;
namespace SafeExamBrowser.Proctoring.ScreenProctoring.Service.Requests
{
internal static class Extensions
{
internal static string ToLogString(this HttpResponseMessage response)
{
return response == default ? "No Response" : $"{(int) response.StatusCode} {response.StatusCode} {response.ReasonPhrase}";
}
internal static string ToSummary(this Exception exception)
{
var trimChars = new[] { '.', '!' };
var summary = new StringBuilder(exception.Message?.TrimEnd(trimChars));
for (var inner = exception.InnerException; inner != default; inner = inner.InnerException)
{
summary.Append($" -> {inner.Message?.TrimEnd(trimChars)}");
}
return summary.ToString();
}
internal static long ToUnixTimestamp(this DateTime date)
{
return new DateTimeOffset(date).ToUnixTimeMilliseconds();
}
}
}

31
SafeExamBrowser.Proctoring/ScreenProctoring/Service/Requests/Header.cs Normal file
View File

@@ -0,0 +1,31 @@
/*
* Copyright (c) 2024 ETH Zürich, IT Services
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
namespace SafeExamBrowser.Proctoring.ScreenProctoring.Service.Requests
{
internal static class Header
{
internal const string ACCEPT = "Accept";
internal const string AUTHORIZATION = "Authorization";
internal const string GROUP_ID = "SEB_GROUP_UUID";
internal const string HEALTH = "sps_server_health";
internal const string IMAGE_FORMAT = "imageFormat";
internal const string METADATA = "metaData";
internal const string SESSION_ID = "SEB_SESSION_UUID";
internal const string TIMESTAMP = "timestamp";
internal static class Metadata
{
internal const string ApplicationInfo = "screenProctoringMetadataApplication";
internal const string BrowserInfo = "screenProctoringMetadataBrowser";
internal const string BrowserUrls = "screenProctoringMetadataURL";
internal const string TriggerInfo = "screenProctoringMetadataUserAction";
internal const string WindowTitle = "screenProctoringMetadataWindowTitle";
}
}
}

36
SafeExamBrowser.Proctoring/ScreenProctoring/Service/Requests/HealthRequest.cs Normal file
View File

@@ -0,0 +1,36 @@
/*
* Copyright (c) 2024 ETH Zürich, IT Services
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
using System.Net.Http;
using SafeExamBrowser.Logging.Contracts;
namespace SafeExamBrowser.Proctoring.ScreenProctoring.Service.Requests
{
internal class HealthRequest : Request
{
internal HealthRequest(Api api, HttpClient httpClient, ILogger logger, Parser parser) : base(api, httpClient, logger, parser)
{
}
internal bool TryExecute(out int health, out string message)
{
var url = api.HealthEndpoint;
var success = TryExecute(HttpMethod.Get, url, out var response);
health = default;
message = response.ToLogString();
if (success)
{
parser.TryParseHealth(response, out health);
}
return success;
}
}
}

28
SafeExamBrowser.Proctoring/ScreenProctoring/Service/Requests/OAuth2TokenRequest.cs Normal file
View File

@@ -0,0 +1,28 @@
/*
* Copyright (c) 2024 ETH Zürich, IT Services
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
using System.Net.Http;
using SafeExamBrowser.Logging.Contracts;
namespace SafeExamBrowser.Proctoring.ScreenProctoring.Service.Requests
{
internal class OAuth2TokenRequest : Request
{
internal OAuth2TokenRequest(Api api, HttpClient httpClient, ILogger logger, Parser parser) : base(api, httpClient, logger, parser)
{
}
internal bool TryExecute(string clientId, string clientSecret, out string message)
{
ClientId = clientId;
ClientSecret = clientSecret;
return TryRetrieveOAuth2Token(out message);
}
}
}

181
SafeExamBrowser.Proctoring/ScreenProctoring/Service/Requests/Request.cs Normal file
View File

@@ -0,0 +1,181 @@
/*
* Copyright (c) 2024 ETH Zürich, IT Services
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using SafeExamBrowser.Logging.Contracts;
namespace SafeExamBrowser.Proctoring.ScreenProctoring.Service.Requests
{
internal abstract class Request
{
private const int ATTEMPTS = 5;
private static string oauth2Token;
private readonly HttpClient httpClient;
private bool hadException;
protected readonly Api api;
protected readonly ILogger logger;
protected readonly Parser parser;
protected static string ClientId { get; set; }
protected static string ClientSecret { get; set; }
protected (string, string) Authorization => (Header.AUTHORIZATION, $"Bearer {oauth2Token}");
protected Request(Api api, HttpClient httpClient, ILogger logger, Parser parser)
{
this.api = api;
this.httpClient = httpClient;
this.logger = logger;
this.parser = parser;
}
protected bool TryExecute(
HttpMethod method,
string url,
out HttpResponseMessage response,
object content = default,
string contentType = default,
params (string name, string value)[] headers)
{
response = default;
for (var attempt = 0; attempt < ATTEMPTS && (response == default || !response.IsSuccessStatusCode); attempt++)
{
var request = BuildRequest(method, url, content, contentType, headers);
try
{
response = httpClient.SendAsync(request).GetAwaiter().GetResult();
logger.Debug($"Completed request: {request.Method} '{request.RequestUri}' -> {response.ToLogString()}");
if (response.StatusCode == HttpStatusCode.Unauthorized && parser.IsTokenExpired(response.Content))
{
logger.Info("OAuth2 token has expired, attempting to retrieve new one...");
if (TryRetrieveOAuth2Token(out var message))
{
headers = UpdateOAuth2Token(headers);
}
}
}
catch (TaskCanceledException)
{
logger.Warn($"Request {request.Method} '{request.RequestUri}' did not complete within {httpClient.Timeout}!");
break;
}
catch (Exception e)
{
if (IsFirstException())
{
logger.Warn($"Request {request.Method} '{request.RequestUri}' has failed: {e.ToSummary()}!");
}
}
}
return response != default && response.IsSuccessStatusCode;
}
protected bool TryRetrieveOAuth2Token(out string message)
{
var secret = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{ClientId}:{ClientSecret}"));
var authorization = (Header.AUTHORIZATION, $"Basic {secret}");
var content = "grant_type=client_credentials&scope=read write";
var success = TryExecute(HttpMethod.Post, api.AccessTokenEndpoint, out var response, content, ContentType.URL_ENCODED, authorization);
message = response.ToLogString();
if (success && parser.TryParseOauth2Token(response.Content, out oauth2Token))
{
logger.Info("Successfully retrieved OAuth2 token.");
}
else
{
logger.Error("Failed to retrieve OAuth2 token!");
}
return success;
}
private HttpRequestMessage BuildRequest(
HttpMethod method,
string url,
object content = default,
string contentType = default,
params (string name, string value)[] headers)
{
var request = new HttpRequestMessage(method, url);
if (content != default)
{
if (content is string)
{
request.Content = new StringContent(content as string, Encoding.UTF8);
}
if (content is byte[])
{
request.Content = new ByteArrayContent(content as byte[]);
}
if (contentType != default)
{
request.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(contentType);
}
}
request.Headers.Add(Header.ACCEPT, "application/json, */*");
foreach (var (name, value) in headers)
{
request.Headers.Add(name, value);
}
return request;
}
private bool IsFirstException()
{
var isFirst = !hadException;
hadException = true;
return isFirst;
}
private (string name, string value)[] UpdateOAuth2Token((string name, string value)[] headers)
{
var result = new List<(string name, string value)>();
foreach (var header in headers)
{
if (header.name == Header.AUTHORIZATION)
{
result.Add((Header.AUTHORIZATION, $"Bearer {oauth2Token}"));
}
else
{
result.Add(header);
}
}
return result.ToArray();
}
}
}

61
SafeExamBrowser.Proctoring/ScreenProctoring/Service/Requests/ScreenShotRequest.cs Normal file
View File

@@ -0,0 +1,61 @@
/*
* Copyright (c) 2024 ETH Zürich, IT Services
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
using System;
using System.Net;
using System.Net.Http;
using SafeExamBrowser.Logging.Contracts;
using SafeExamBrowser.Proctoring.ScreenProctoring.Data;
using SafeExamBrowser.Proctoring.ScreenProctoring.Imaging;
using SafeExamBrowser.Settings.Proctoring;
namespace SafeExamBrowser.Proctoring.ScreenProctoring.Service.Requests
{
internal class ScreenShotRequest : Request
{
internal ScreenShotRequest(Api api, HttpClient httpClient, ILogger logger, Parser parser) : base(api, httpClient, logger, parser)
{
}
internal bool TryExecute(MetaData metaData, ScreenShot screenShot, string sessionId, out int health, out string message)
{
var imageFormat = (Header.IMAGE_FORMAT, ToString(screenShot.Format));
var metdataJson = (Header.METADATA, WebUtility.UrlEncode(metaData.ToJson()));
var timestamp = (Header.TIMESTAMP, screenShot.CaptureTime.ToUnixTimestamp().ToString());
var url = api.ScreenShotEndpoint.Replace(Api.SESSION_ID, sessionId);
var success = TryExecute(HttpMethod.Post, url, out var response, screenShot.Data, ContentType.OCTET_STREAM, Authorization, imageFormat, metdataJson, timestamp);
health = default;
message = response.ToLogString();
if (success)
{
parser.TryParseHealth(response, out health);
}
return success;
}
private string ToString(ImageFormat format)
{
switch (format)
{
case ImageFormat.Bmp:
return "bmp";
case ImageFormat.Gif:
return "gif";
case ImageFormat.Jpg:
return "jpg";
case ImageFormat.Png:
return "png";
default:
throw new NotImplementedException($"Image format {format} is not yet implemented!");
}
}
}
}

30
SafeExamBrowser.Proctoring/ScreenProctoring/Service/Requests/TerminateSessionRequest.cs Normal file
View File

@@ -0,0 +1,30 @@
/*
* Copyright (c) 2024 ETH Zürich, IT Services
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
using System.Net.Http;
using SafeExamBrowser.Logging.Contracts;
namespace SafeExamBrowser.Proctoring.ScreenProctoring.Service.Requests
{
internal class TerminateSessionRequest : Request
{
internal TerminateSessionRequest(Api api, HttpClient httpClient, ILogger logger, Parser parser) : base(api, httpClient, logger, parser)
{
}
internal bool TryExecute(string sessionId, out string message)
{
var url = $"{api.SessionEndpoint}/{sessionId}";
var success = TryExecute(HttpMethod.Delete, url, out var response, contentType: ContentType.URL_ENCODED, headers: Authorization);
message = response.ToLogString();
return success;
}
}
}