Initial version
This commit is contained in:
commit
e5b6226a85
68 changed files with 7338 additions and 0 deletions
93
DataTransfer.Client/Components/Icon.razor
Normal file
93
DataTransfer.Client/Components/Icon.razor
Normal file
|
|
@ -0,0 +1,93 @@
|
|||
@* Small stroke icon set (24×24 grid) drawn with currentColor, so icons follow the surrounding text color. *@
|
||||
<svg class="icon @Class" viewBox="0 0 24 24" aria-hidden="true" focusable="false">
|
||||
@switch (Name)
|
||||
{
|
||||
case "transfer":
|
||||
<path d="M4 9h15l-4-4"/>
|
||||
<path d="M20 15H5l4 4"/>
|
||||
break;
|
||||
case "lock":
|
||||
<rect x="5" y="11" width="14" height="10" rx="2"/>
|
||||
<path d="M8 11V7a4 4 0 0 1 8 0v4"/>
|
||||
break;
|
||||
case "shield":
|
||||
<path d="M12 3l7 3v6c0 4.5-3 7.7-7 9-4-1.3-7-4.5-7-9V6z"/>
|
||||
<path d="M9 12l2 2 4-4"/>
|
||||
break;
|
||||
case "plus":
|
||||
<path d="M12 5v14M5 12h14"/>
|
||||
break;
|
||||
case "join":
|
||||
<path d="M14 4h4a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2h-4"/>
|
||||
<path d="M10 16l4-4-4-4M14 12H4"/>
|
||||
break;
|
||||
case "arrow-up":
|
||||
<path d="M12 19V5M6 11l6-6 6 6"/>
|
||||
break;
|
||||
case "arrow-down":
|
||||
<path d="M12 5v14M6 13l6 6 6-6"/>
|
||||
break;
|
||||
case "arrow-right":
|
||||
<path d="M5 12h14M13 6l6 6-6 6"/>
|
||||
break;
|
||||
case "file":
|
||||
<path d="M14 3H7a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V8z"/>
|
||||
<path d="M14 3v5h5"/>
|
||||
break;
|
||||
case "upload":
|
||||
<path d="M12 15V4M7 9l5-5 5 5"/>
|
||||
<path d="M4 15v3a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-3"/>
|
||||
break;
|
||||
case "download":
|
||||
<path d="M12 4v11M7 10l5 5 5-5"/>
|
||||
<path d="M4 15v3a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-3"/>
|
||||
break;
|
||||
case "copy":
|
||||
<rect x="9" y="9" width="11" height="11" rx="2"/>
|
||||
<path d="M15 5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v8a2 2 0 0 0 2 2"/>
|
||||
break;
|
||||
case "check":
|
||||
<path d="M5 12.5l4.5 4.5L19 7.5"/>
|
||||
break;
|
||||
case "close":
|
||||
<path d="M6 6l12 12M18 6L6 18"/>
|
||||
break;
|
||||
case "info":
|
||||
<circle cx="12" cy="12" r="9"/>
|
||||
<path d="M12 11v5M12 8h.01"/>
|
||||
break;
|
||||
case "alert":
|
||||
<path d="M12 3.5L2.5 20h19z"/>
|
||||
<path d="M12 10v4M12 17h.01"/>
|
||||
break;
|
||||
case "power":
|
||||
<path d="M12 3v9"/>
|
||||
<path d="M6.3 6.3a8 8 0 1 0 11.4 0"/>
|
||||
break;
|
||||
case "inbox":
|
||||
<path d="M3 13l3-8h12l3 8v5a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"/>
|
||||
<path d="M3 13h5l1.5 2.5h5L16 13h5"/>
|
||||
break;
|
||||
case "clock":
|
||||
<circle cx="12" cy="12" r="9"/>
|
||||
<path d="M12 7v5l3 2"/>
|
||||
break;
|
||||
case "file-text":
|
||||
<path d="M14 3H7a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V8z"/>
|
||||
<path d="M14 3v5h5M9 13h6M9 17h6"/>
|
||||
break;
|
||||
case "flag":
|
||||
<path d="M5 21V4"/>
|
||||
<path d="M5 4h12l-2.5 4.5L17 13H5"/>
|
||||
break;
|
||||
case "code":
|
||||
<path d="M8 7l-5 5 5 5M16 7l5 5-5 5M14 4l-4 16"/>
|
||||
break;
|
||||
}
|
||||
</svg>
|
||||
|
||||
@code {
|
||||
[Parameter][EditorRequired] public string Name { get; set; } = string.Empty;
|
||||
|
||||
[Parameter] public string? Class { get; set; }
|
||||
}
|
||||
38
DataTransfer.Client/Components/ServerLoad.razor
Normal file
38
DataTransfer.Client/Components/ServerLoad.razor
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
@implements IDisposable
|
||||
@inject ServerStatusMonitor Monitor
|
||||
|
||||
@if (Monitor.Current is { } status)
|
||||
{
|
||||
<span class="server-load @LoadClass(status)" title="@Describe(status)" data-testid="server-load">
|
||||
<span class="server-load-dot" aria-hidden="true"></span>
|
||||
<span class="server-load-count">@status.ActiveConnections/@status.MaxConnections</span>
|
||||
<span class="server-load-label">connections</span>
|
||||
@if (status.QueuedClients > 0)
|
||||
{
|
||||
<span class="server-load-queue">· @status.QueuedClients queued</span>
|
||||
}
|
||||
</span>
|
||||
}
|
||||
|
||||
@code {
|
||||
|
||||
protected override void OnInitialized()
|
||||
{
|
||||
Monitor.Changed += OnMonitorChanged;
|
||||
Monitor.EnsureStarted();
|
||||
}
|
||||
|
||||
public void Dispose() => Monitor.Changed -= OnMonitorChanged;
|
||||
|
||||
private void OnMonitorChanged() => _ = InvokeAsync(StateHasChanged);
|
||||
|
||||
private static string LoadClass(ServerStatus status) =>
|
||||
status.ActiveConnections >= status.MaxConnections ? "is-full"
|
||||
: status.ActiveConnections * 5 >= status.MaxConnections * 4 ? "is-high"
|
||||
: "is-ok";
|
||||
|
||||
private static string Describe(ServerStatus status) =>
|
||||
$"{status.ActiveConnections} of {status.MaxConnections} connections in use"
|
||||
+ (status.QueuedClients > 0 ? $", {status.QueuedClients} waiting in the queue" : null);
|
||||
|
||||
}
|
||||
36
DataTransfer.Client/Components/ServerLoad.razor.css
Normal file
36
DataTransfer.Client/Components/ServerLoad.razor.css
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
/* Lives in the always-dark header, so the colors are fixed instead of following the theme tokens. */
|
||||
.server-load {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
gap: 0.375rem;
|
||||
color: var(--header-muted);
|
||||
font-size: 0.8125rem;
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
.server-load-dot {
|
||||
width: 0.5rem;
|
||||
height: 0.5rem;
|
||||
border-radius: 50%;
|
||||
background-color: #4cb167;
|
||||
}
|
||||
|
||||
.is-high .server-load-dot {
|
||||
background-color: #e0a63c;
|
||||
}
|
||||
|
||||
.is-full .server-load-dot {
|
||||
background-color: #ef6b65;
|
||||
}
|
||||
|
||||
.server-load-count {
|
||||
color: var(--header-text);
|
||||
font-family: var(--mono);
|
||||
font-variant-numeric: tabular-nums;
|
||||
}
|
||||
|
||||
@media (max-width: 560px) {
|
||||
.server-load-label {
|
||||
display: none;
|
||||
}
|
||||
}
|
||||
18
DataTransfer.Client/DataTransfer.Client.csproj
Normal file
18
DataTransfer.Client/DataTransfer.Client.csproj
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
<Project Sdk="Microsoft.NET.Sdk.BlazorWebAssembly">
|
||||
|
||||
<PropertyGroup>
|
||||
<TargetFramework>net10.0</TargetFramework>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
<NoDefaultLaunchSettingsFile>true</NoDefaultLaunchSettingsFile>
|
||||
<StaticWebAssetProjectMode>Default</StaticWebAssetProjectMode>
|
||||
<BlazorDisableThrowNavigationException>true</BlazorDisableThrowNavigationException>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="10.0.13"/>
|
||||
<PackageReference Include="Microsoft.AspNetCore.SignalR.Client" Version="10.0.13"/>
|
||||
<PackageReference Include="SpawnDev.BlazorJS.Cryptography" Version="3.2.0"/>
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
446
DataTransfer.Client/Pages/Link.razor
Normal file
446
DataTransfer.Client/Pages/Link.razor
Normal file
|
|
@ -0,0 +1,446 @@
|
|||
@page "/"
|
||||
@rendermode @(new InteractiveWebAssemblyRenderMode(false))
|
||||
|
||||
@if (!_cryptoSupported)
|
||||
{
|
||||
<header class="page-head">
|
||||
<h1>Start a transfer</h1>
|
||||
</header>
|
||||
<div class="notice notice-danger" role="alert">
|
||||
<Icon Name="alert"/>
|
||||
<div class="notice-text">
|
||||
<strong>End-to-end encryption is not available.</strong>
|
||||
This browser cannot encrypt end-to-end. Please use a current browser and open this site via HTTPS.
|
||||
</div>
|
||||
</div>
|
||||
}
|
||||
else
|
||||
{
|
||||
@if (_error is not null)
|
||||
{
|
||||
<div class="notice notice-danger" role="alert" data-testid="error">
|
||||
<Icon Name="alert"/>
|
||||
<span class="notice-text">@_error</span>
|
||||
<button type="button" class="btn btn-ghost btn-sm btn-icon" title="Dismiss" aria-label="Dismiss"
|
||||
@onclick="() => _error = null">
|
||||
<Icon Name="close"/>
|
||||
</button>
|
||||
</div>
|
||||
}
|
||||
|
||||
@switch (Session.State)
|
||||
{
|
||||
case SessionState.Idle:
|
||||
case SessionState.Joining:
|
||||
<header class="page-head">
|
||||
<h1>Start a transfer</h1>
|
||||
<p>Connect two browsers with a one-time code. Messages and files are encrypted on this device before
|
||||
they are sent.</p>
|
||||
</header>
|
||||
|
||||
<div class="panel connect">
|
||||
<section class="connect-option">
|
||||
<h2 class="connect-title"><span class="connect-icon"><Icon Name="plus"/></span>Create a connection
|
||||
</h2>
|
||||
<p class="connect-text">
|
||||
Generates a one-time code. Share it with the person you want to exchange messages and files
|
||||
with.
|
||||
</p>
|
||||
@if (Load is { } load && IsServerFull)
|
||||
{
|
||||
<p class="capacity-note" data-testid="capacity-note">
|
||||
<Icon Name="clock"/>
|
||||
<span>
|
||||
The server is full (@load.ActiveConnections/@load.MaxConnections connections in use@(load.QueuedClients > 0 ? $", {load.QueuedClients} waiting" : null)).
|
||||
You will be placed in a queue.
|
||||
</span>
|
||||
</p>
|
||||
}
|
||||
<div>
|
||||
<button type="button" class="btn btn-primary" disabled="@IsBusy" @onclick="CreateAsync"
|
||||
data-testid="create">
|
||||
@if (_pending == PendingAction.Create)
|
||||
{
|
||||
<span class="spinner" aria-hidden="true"></span>
|
||||
<span>@(Session.IsVerifyingBrowser ? "Verifying browser…" : "Creating…")</span>
|
||||
}
|
||||
else
|
||||
{
|
||||
<span>Create connection</span>
|
||||
}
|
||||
</button>
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<div class="connect-divider" aria-hidden="true"><span>or</span></div>
|
||||
|
||||
<section class="connect-option">
|
||||
<h2 class="connect-title"><span class="connect-icon"><Icon Name="join"/></span>Join a connection
|
||||
</h2>
|
||||
<p class="connect-text">Enter the code you received.</p>
|
||||
<div class="join-row">
|
||||
<input class="input code-input" placeholder="ABCDE-FGHJK" maxlength="20"
|
||||
autocomplete="off" spellcheck="false" aria-label="Connection code"
|
||||
data-testid="join-code"
|
||||
@bind="_joinCode" @bind:event="oninput" @onkeydown="OnJoinKeyDownAsync"/>
|
||||
<button type="button" class="btn btn-primary" disabled="@IsBusy" @onclick="JoinAsync"
|
||||
data-testid="join">
|
||||
@if (_pending == PendingAction.Join)
|
||||
{
|
||||
<span class="spinner" aria-hidden="true"></span>
|
||||
<span>Joining…</span>
|
||||
}
|
||||
else
|
||||
{
|
||||
<span>Join</span>
|
||||
}
|
||||
</button>
|
||||
</div>
|
||||
</section>
|
||||
</div>
|
||||
|
||||
<ol class="steps">
|
||||
<li>
|
||||
<span class="step-no">01</span>
|
||||
<div><strong>Create</strong> One side creates a connection and shares the code.</div>
|
||||
</li>
|
||||
<li>
|
||||
<span class="step-no">02</span>
|
||||
<div><strong>Join</strong> The other side enters the code to connect.</div>
|
||||
</li>
|
||||
<li>
|
||||
<span class="step-no">03</span>
|
||||
<div><strong>Verify & transfer</strong> Compare the safety code, then send messages and files.
|
||||
</div>
|
||||
</li>
|
||||
</ol>
|
||||
break;
|
||||
|
||||
case SessionState.Queued:
|
||||
<header class="page-head">
|
||||
<h1>Waiting for a free slot</h1>
|
||||
<p>
|
||||
The server has reached its connection limit. Your connection is created automatically as soon as
|
||||
another
|
||||
one closes – keep this page open.
|
||||
</p>
|
||||
</header>
|
||||
|
||||
<section class="panel waiting" aria-labelledby="queue-title">
|
||||
<div class="panel-header">
|
||||
<h2 class="panel-title" id="queue-title">Queue</h2>
|
||||
</div>
|
||||
<div class="panel-body waiting-body">
|
||||
<div class="queue-position" aria-live="polite">
|
||||
<span class="queue-number" data-testid="queue-position">@Session.QueuePosition</span>
|
||||
<div class="queue-text">
|
||||
<strong>@QueueAheadText</strong>
|
||||
<span class="muted">Position in the queue</span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="waiting-status">
|
||||
<span class="spinner" aria-hidden="true"></span>
|
||||
<span>Waiting for a connection to close…</span>
|
||||
@if (Load is { } queueLoad)
|
||||
{
|
||||
<span class="waiting-expiry">
|
||||
<span class="mono">@queueLoad.ActiveConnections/@queueLoad.MaxConnections</span> connections in use
|
||||
</span>
|
||||
}
|
||||
</div>
|
||||
</div>
|
||||
<div class="panel-footer">
|
||||
<button type="button" class="btn btn-danger" @onclick="ResetAsync" data-testid="leave-queue">Leave
|
||||
queue
|
||||
</button>
|
||||
</div>
|
||||
</section>
|
||||
break;
|
||||
|
||||
case SessionState.Waiting:
|
||||
<header class="page-head">
|
||||
<h1>Share the code</h1>
|
||||
<p>Give this code to the person you want to connect with, for example by phone or messenger. It can only
|
||||
be used once.</p>
|
||||
</header>
|
||||
|
||||
<section class="panel waiting" aria-labelledby="code-title">
|
||||
<div class="panel-header">
|
||||
<h2 class="panel-title" id="code-title">Connection code</h2>
|
||||
</div>
|
||||
<div class="panel-body waiting-body">
|
||||
<div class="code-display">
|
||||
<div class="code-chars" data-testid="connection-code">
|
||||
@foreach (var c in DisplayCode ?? string.Empty)
|
||||
{
|
||||
<span class="@(c == '-' ? "code-sep" : "code-char")">@c</span>
|
||||
}
|
||||
</div>
|
||||
<button type="button" class="btn" @onclick="CopyCodeAsync">
|
||||
<Icon Name="@(_copied ? "check" : "copy")"/>
|
||||
<span>@(_copied ? "Copied" : "Copy code")</span>
|
||||
</button>
|
||||
</div>
|
||||
|
||||
<div class="waiting-status">
|
||||
<span class="spinner" aria-hidden="true"></span>
|
||||
<span data-testid="waiting-status">@(Session.IsPeerJoining ? "The other person joined. Securing the connection…" : "Waiting for the other person to join…")</span>
|
||||
<span class="waiting-expiry">Expires in <span class="mono">@RemainingTime</span></span>
|
||||
</div>
|
||||
<div class="progress countdown @(RemainingPercent <= 20 ? "is-low" : null)" aria-hidden="true">
|
||||
<div class="progress-bar" style="width: @(RemainingPercent)%"></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="panel-footer">
|
||||
<button type="button" class="btn btn-danger" @onclick="ResetAsync">Cancel</button>
|
||||
</div>
|
||||
</section>
|
||||
break;
|
||||
|
||||
default:
|
||||
var connected = Session.State == SessionState.Connected;
|
||||
|
||||
@if (connected)
|
||||
{
|
||||
<section class="panel session">
|
||||
<div class="session-main">
|
||||
<h1 class="session-state"><span class="status status-online"
|
||||
data-testid="status">Connected</span></h1>
|
||||
<dl class="session-facts">
|
||||
<div>
|
||||
<dt>Code</dt>
|
||||
<dd class="mono">@DisplayCode</dd>
|
||||
</div>
|
||||
<div>
|
||||
<dt>Safety code</dt>
|
||||
<dd class="mono safety-code" data-testid="safety-code">@Session.SafetyCode</dd>
|
||||
</div>
|
||||
<div
|
||||
title="The connection closes after @DisplayFormat.Duration(Session.InactivityTimeout) without transfers.">
|
||||
<dt>Idle timeout · @DisplayFormat.Duration(Session.InactivityTimeout)</dt>
|
||||
<dd><span class="mono" data-testid="remaining">@RemainingTime</span> left</dd>
|
||||
</div>
|
||||
</dl>
|
||||
<button type="button" class="btn btn-danger btn-sm" @onclick="DisconnectAsync"
|
||||
data-testid="disconnect">
|
||||
<Icon Name="power"/>
|
||||
<span>Disconnect</span>
|
||||
</button>
|
||||
</div>
|
||||
<p class="session-hint">
|
||||
<Icon Name="shield"/>
|
||||
<span>
|
||||
Compare the safety code with your partner over another channel (e.g. by phone). If both codes match,
|
||||
nobody else – not even this server – can read your messages and files.
|
||||
</span>
|
||||
</p>
|
||||
</section>
|
||||
}
|
||||
else
|
||||
{
|
||||
<section class="panel session" role="status">
|
||||
<div class="session-main">
|
||||
<h1 class="session-state"><span class="status status-offline">Disconnected</span></h1>
|
||||
<div class="session-closed">
|
||||
<span data-testid="closed-message">@Session.ClosedMessage</span>
|
||||
@if (Session.HasPeer)
|
||||
{
|
||||
<span
|
||||
class="muted">Received files stay available until you start a new connection.</span>
|
||||
}
|
||||
</div>
|
||||
<button type="button" class="btn btn-primary btn-sm" @onclick="ResetAsync"
|
||||
data-testid="new-connection">
|
||||
New connection
|
||||
</button>
|
||||
</div>
|
||||
</section>
|
||||
}
|
||||
|
||||
@if (Session.HasPeer)
|
||||
{
|
||||
<div class="workspace @(connected ? null : "is-closed")">
|
||||
@if (connected)
|
||||
{
|
||||
<section class="panel send" aria-labelledby="send-title">
|
||||
<div class="panel-header">
|
||||
<h2 class="panel-title" id="send-title">Send</h2>
|
||||
</div>
|
||||
<div class="panel-body send-body">
|
||||
<label
|
||||
class="dropzone @(_dragging ? "is-dragging" : null) @(Session.IsSendingFiles ? "is-busy" : null)"
|
||||
@ondragenter="() => _dragging = true" @ondragleave="() => _dragging = false"
|
||||
@ondrop="() => _dragging = false"
|
||||
@ondragover:preventDefault="@Session.IsSendingFiles"
|
||||
@ondrop:preventDefault="@Session.IsSendingFiles">
|
||||
@if (Session.IsSendingFiles)
|
||||
{
|
||||
<span class="spinner dropzone-spinner" aria-hidden="true"></span>
|
||||
<strong>Sending files…</strong>
|
||||
<span>You can add more files when these are sent.</span>
|
||||
}
|
||||
else
|
||||
{
|
||||
<Icon Name="upload" Class="dropzone-icon"/>
|
||||
<strong>Drop files here or <span class="dropzone-browse">browse</span></strong>
|
||||
<span>Up to @MaxFilesPerSelection files at once, max. @(TransferProtocol.MaxFileBytes / (1024 * 1024)) MB each</span>
|
||||
}
|
||||
<InputFile class="dropzone-input" multiple OnChange="OnFilesSelectedAsync"
|
||||
disabled="@Session.IsSendingFiles"
|
||||
title="Choose files to send" data-testid="file-input"/>
|
||||
</label>
|
||||
|
||||
<div class="send-message">
|
||||
<label class="field-label" for="message">Message</label>
|
||||
<textarea id="message" class="input" rows="4"
|
||||
maxlength="@TransferProtocol.MaxMessageLength"
|
||||
placeholder="Text, links, notes…" data-testid="message-input"
|
||||
@bind="_message" @bind:event="oninput"
|
||||
@onkeydown="OnMessageKeyDownAsync"></textarea>
|
||||
<div class="send-actions">
|
||||
<span class="hint"><kbd>Ctrl</kbd> + <kbd>Enter</kbd> to send</span>
|
||||
<button type="button" class="btn btn-primary"
|
||||
disabled="@(_sendingMessage || string.IsNullOrWhiteSpace(_message))"
|
||||
@onclick="SendMessageAsync" data-testid="send">
|
||||
<span>Send</span>
|
||||
<Icon Name="arrow-right"/>
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</section>
|
||||
}
|
||||
|
||||
<section class="panel log" aria-labelledby="log-title">
|
||||
<div class="panel-header">
|
||||
<h2 class="panel-title" id="log-title">Transfers</h2>
|
||||
<span class="log-summary">
|
||||
<span><Icon Name="arrow-up"/>@SentCount sent</span>
|
||||
<span><Icon Name="arrow-down"/>@ReceivedCount received</span>
|
||||
</span>
|
||||
</div>
|
||||
@* column-reverse keeps the log scrolled to the newest entry without any JavaScript. *@
|
||||
<div class="log-scroll" aria-live="polite" data-testid="chat-log">
|
||||
@if (Session.Entries.Count == 0)
|
||||
{
|
||||
<div class="log-empty">
|
||||
<Icon Name="inbox"/>
|
||||
<strong>Nothing transferred yet</strong>
|
||||
<span>Messages and files are encrypted in your browser before they leave it.</span>
|
||||
</div>
|
||||
}
|
||||
else
|
||||
{
|
||||
<ol class="log-entries">
|
||||
@foreach (var entry in Session.Entries)
|
||||
{
|
||||
@if (entry.Kind == ChatEntryKind.System)
|
||||
{
|
||||
<li class="entry entry-system @(entry.Error is null ? null : "is-error")">
|
||||
<span class="entry-dir"><Icon
|
||||
Name="@(entry.Error is null ? "info" : "alert")"/></span>
|
||||
<div class="entry-body">@entry.Text</div>
|
||||
<div class="entry-meta">
|
||||
<time class="entry-time">@entry.Time.ToString("t")</time>
|
||||
</div>
|
||||
</li>
|
||||
}
|
||||
else
|
||||
{
|
||||
var outgoing = entry.Kind == ChatEntryKind.Outgoing;
|
||||
<li class="entry @(outgoing ? "entry-out" : "entry-in")">
|
||||
<span class="entry-dir" title="@(outgoing ? "Sent" : "Received")">
|
||||
<Icon Name="@(outgoing ? "arrow-up" : "arrow-down")"/>
|
||||
<span
|
||||
class="visually-hidden">@(outgoing ? "Sent" : "Received")</span>
|
||||
</span>
|
||||
<div class="entry-body">
|
||||
@if (entry.IsFile)
|
||||
{
|
||||
<div class="entry-file" title="@entry.FileName">
|
||||
<Icon Name="file"/>
|
||||
<span class="entry-name">@entry.FileName</span>
|
||||
</div>
|
||||
@if (entry.IsRiskyFile)
|
||||
{
|
||||
<div class="entry-warning" role="note" data-testid="risky-file-warning">
|
||||
<Icon Name="alert"/>
|
||||
<span>
|
||||
This file type can run programs or scripts on your device. Only open it if
|
||||
you know the sender and expected this file.
|
||||
</span>
|
||||
</div>
|
||||
}
|
||||
@if (entry.Error is not null)
|
||||
{
|
||||
<div class="entry-error">@entry.Error</div>
|
||||
}
|
||||
else if (entry.IsTransferring)
|
||||
{
|
||||
<div class="progress entry-progress" role="progressbar"
|
||||
aria-label="@(outgoing ? "Sending" : "Receiving") @entry.FileName"
|
||||
aria-valuenow="@entry.ProgressPercent"
|
||||
aria-valuemin="0" aria-valuemax="100">
|
||||
<div class="progress-bar"
|
||||
style="width: @(entry.ProgressPercent)%"></div>
|
||||
</div>
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
<div class="entry-text">@entry.Text</div>
|
||||
}
|
||||
</div>
|
||||
<div class="entry-meta">
|
||||
<span
|
||||
class="entry-size">@(entry.IsFile ? DisplayFormat.Bytes(entry.FileSize) : null)</span>
|
||||
<time class="entry-time">@entry.Time.ToString("t")</time>
|
||||
</div>
|
||||
<div class="entry-action">
|
||||
@if (!entry.IsFile)
|
||||
{
|
||||
<button type="button" class="btn btn-ghost btn-sm btn-icon"
|
||||
title="Copy text" aria-label="Copy text"
|
||||
@onclick="() => CopyEntryAsync(entry)">
|
||||
<Icon
|
||||
Name="@(ReferenceEquals(_copiedEntry, entry) ? "check" : "copy")"/>
|
||||
</button>
|
||||
}
|
||||
else if (entry.Error is not null)
|
||||
{
|
||||
<span class="tag tag-danger">Failed</span>
|
||||
}
|
||||
else if (entry.IsTransferring)
|
||||
{
|
||||
<span
|
||||
class="tag tag-progress mono">@entry.ProgressPercent%</span>
|
||||
}
|
||||
else if (entry.DownloadUrl is not null)
|
||||
{
|
||||
<a class="btn btn-sm" href="@entry.DownloadUrl"
|
||||
download="@entry.FileName" title="Save @entry.FileName">
|
||||
<Icon Name="download"/>
|
||||
<span>Save</span>
|
||||
<span class="visually-hidden">@entry.FileName</span>
|
||||
</a>
|
||||
}
|
||||
else
|
||||
{
|
||||
<span class="tag tag-success"><Icon
|
||||
Name="check"/>@(outgoing ? "Sent" : "Received")</span>
|
||||
}
|
||||
</div>
|
||||
</li>
|
||||
}
|
||||
}
|
||||
</ol>
|
||||
}
|
||||
</div>
|
||||
</section>
|
||||
</div>
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
398
DataTransfer.Client/Pages/Link.razor.cs
Normal file
398
DataTransfer.Client/Pages/Link.razor.cs
Normal file
|
|
@ -0,0 +1,398 @@
|
|||
using System.Diagnostics;
|
||||
using System.Net;
|
||||
using DataTransfer.Client.Services;
|
||||
using DataTransfer.Client.Shared;
|
||||
using Microsoft.AspNetCore.Components;
|
||||
using Microsoft.AspNetCore.Components.Forms;
|
||||
using Microsoft.AspNetCore.Components.Web;
|
||||
using SpawnDev.BlazorJS;
|
||||
using SpawnDev.BlazorJS.Cryptography;
|
||||
using SpawnDev.BlazorJS.JSObjects;
|
||||
|
||||
namespace DataTransfer.Client.Pages;
|
||||
|
||||
public sealed partial class Link : ComponentBase, IAsyncDisposable
|
||||
{
|
||||
private const int MaxFilesPerSelection = 20;
|
||||
|
||||
// Frames can arrive ten times per second; re-rendering the whole log for each would make the page sluggish.
|
||||
private static readonly TimeSpan MinRenderInterval = TimeSpan.FromMilliseconds(250);
|
||||
|
||||
private TransferSession? _session;
|
||||
private SessionState _observedState;
|
||||
private string? _documentTitle;
|
||||
private Window? _window;
|
||||
private bool _isLeaveGuardActive;
|
||||
private long _lastRenderTimestamp;
|
||||
private bool _isRenderScheduled;
|
||||
private Timer? _ticker;
|
||||
private bool _cryptoSupported;
|
||||
private PendingAction _pending;
|
||||
private bool _copied;
|
||||
private bool _dragging;
|
||||
private bool _sendingMessage;
|
||||
private ChatEntry? _copiedEntry;
|
||||
private string? _joinCode;
|
||||
private string? _message;
|
||||
private string? _error;
|
||||
|
||||
private enum PendingAction
|
||||
{
|
||||
None,
|
||||
Create,
|
||||
Join
|
||||
}
|
||||
|
||||
private TransferSession Session => _session!;
|
||||
|
||||
private ServerStatus? Load => Status.Current;
|
||||
|
||||
/// <summary>A new connection would be queued; a non-empty queue also means no slot is available to newcomers.</summary>
|
||||
private bool IsServerFull => Load is { } load && (load.ActiveConnections >= load.MaxConnections || load.QueuedClients > 0);
|
||||
|
||||
private string QueueAheadText => (Session.QueuePosition - 1) switch
|
||||
{
|
||||
<= 0 => "You are next",
|
||||
1 => "1 person ahead of you",
|
||||
var ahead => $"{ahead} people ahead of you"
|
||||
};
|
||||
|
||||
private string Title => _session?.State switch
|
||||
{
|
||||
SessionState.Queued => $"Queue #{Session.QueuePosition} · DataTransfer",
|
||||
SessionState.Waiting => "Waiting for partner · DataTransfer",
|
||||
SessionState.Connected => "Connected · DataTransfer",
|
||||
_ => "DataTransfer"
|
||||
};
|
||||
|
||||
private string? DisplayCode => Session.Code is { } code ? ConnectionCode.Format(code) : null;
|
||||
|
||||
private string RemainingTime => DisplayFormat.Countdown(Session.RemainingTime ?? TimeSpan.Zero);
|
||||
|
||||
private int RemainingPercent => Session.CountdownDuration > TimeSpan.Zero
|
||||
? (int)Math.Clamp((Session.RemainingTime ?? TimeSpan.Zero) / Session.CountdownDuration * 100, 0, 100)
|
||||
: 0;
|
||||
|
||||
private bool IsBusy => _pending != PendingAction.None;
|
||||
|
||||
/// <summary>Reloading or leaving the page now would cancel a queued, pending or established connection.</summary>
|
||||
private bool IsConnectionActive =>
|
||||
_session?.State is SessionState.Queued or SessionState.Joining or SessionState.Waiting or SessionState.Connected;
|
||||
|
||||
private int SentCount => Session.Entries.Count(entry => entry.Kind == ChatEntryKind.Outgoing);
|
||||
|
||||
private int ReceivedCount => Session.Entries.Count(entry => entry.Kind == ChatEntryKind.Incoming);
|
||||
|
||||
[Inject] private NavigationManager Navigation { get; set; } = null!;
|
||||
|
||||
[Inject] private PortableCrypto Crypto { get; set; } = null!;
|
||||
|
||||
[Inject] private BlazorJSRuntime JS { get; set; } = null!;
|
||||
|
||||
[Inject] private ILoggerFactory LoggerFactory { get; set; } = null!;
|
||||
|
||||
[Inject] private ILogger<Link> Logger { get; set; } = null!;
|
||||
|
||||
[Inject] private ServerStatusMonitor Status { get; set; } = null!;
|
||||
|
||||
[Inject] private BotCheckSolver BotCheckSolver { get; set; } = null!;
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
Status.Changed -= OnStatusChanged;
|
||||
SetLeaveGuard(false);
|
||||
_window?.Dispose();
|
||||
if (_ticker is not null)
|
||||
{
|
||||
await _ticker.DisposeAsync();
|
||||
}
|
||||
|
||||
if (_session is not null)
|
||||
{
|
||||
_session.Changed -= OnSessionChanged;
|
||||
await _session.DisposeAsync();
|
||||
}
|
||||
}
|
||||
|
||||
protected override void OnInitialized()
|
||||
{
|
||||
_cryptoSupported = JS.Get<bool>("isSecureContext") && !JS.IsUndefined("crypto.subtle");
|
||||
_session = new TransferSession(Navigation, Crypto, BotCheckSolver, LoggerFactory.CreateLogger<TransferSession>());
|
||||
_session.Changed += OnSessionChanged;
|
||||
_ticker = new Timer(_ => OnTick(), null, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1));
|
||||
Status.Changed += OnStatusChanged;
|
||||
Status.EnsureStarted();
|
||||
}
|
||||
|
||||
protected override void OnAfterRender(bool firstRender)
|
||||
{
|
||||
// The HeadOutlet is rendered statically, so <PageTitle> cannot reach it from this non-prerendered page.
|
||||
var title = Title;
|
||||
if (title != _documentTitle)
|
||||
{
|
||||
_documentTitle = title;
|
||||
JS.Set("document.title", title);
|
||||
}
|
||||
|
||||
SetLeaveGuard(IsConnectionActive);
|
||||
_lastRenderTimestamp = Stopwatch.GetTimestamp();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// While enabled, the browser asks before a reload, closing the tab or clicking the title (which reloads the
|
||||
/// page) cancels the connection.
|
||||
/// </summary>
|
||||
private void SetLeaveGuard(bool enabled)
|
||||
{
|
||||
if (enabled == _isLeaveGuardActive)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_window ??= JS.Get<Window>("window");
|
||||
if (enabled)
|
||||
{
|
||||
_window.OnBeforeUnload += OnBeforeUnload;
|
||||
}
|
||||
else
|
||||
{
|
||||
_window.OnBeforeUnload -= OnBeforeUnload;
|
||||
}
|
||||
|
||||
_isLeaveGuardActive = enabled;
|
||||
}
|
||||
|
||||
private static void OnBeforeUnload(BeforeUnloadEvent beforeUnload)
|
||||
{
|
||||
beforeUnload.PreventDefault();
|
||||
|
||||
// Older browsers only show the dialog when a return value is set; its text is no longer displayed.
|
||||
beforeUnload.ReturnValue = string.Empty;
|
||||
}
|
||||
|
||||
private Task CreateAsync() => RunBusyAsync(
|
||||
PendingAction.Create,
|
||||
() =>
|
||||
{
|
||||
_copied = false;
|
||||
return Session.CreateAsync();
|
||||
});
|
||||
|
||||
private Task JoinAsync() => RunBusyAsync(
|
||||
PendingAction.Join,
|
||||
async () =>
|
||||
{
|
||||
var error = await Session.JoinAsync(_joinCode);
|
||||
if (error is null && Session.State == SessionState.Connected)
|
||||
{
|
||||
_joinCode = null;
|
||||
}
|
||||
|
||||
return error;
|
||||
});
|
||||
|
||||
private async Task RunBusyAsync(PendingAction pending, Func<Task<string?>> action)
|
||||
{
|
||||
if (IsBusy)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_pending = pending;
|
||||
_error = null;
|
||||
try
|
||||
{
|
||||
_error = await action();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
if (IsRateLimited(ex))
|
||||
{
|
||||
Logger.LogWarning("Connecting was rate limited by the server");
|
||||
_error = "Too many connections or connection attempts from your network. Please wait a minute and try again.";
|
||||
}
|
||||
else
|
||||
{
|
||||
Logger.LogError(ex, "Connecting failed");
|
||||
_error = "Connecting to the server failed. Please try again.";
|
||||
}
|
||||
|
||||
await Session.ResetAsync();
|
||||
}
|
||||
finally
|
||||
{
|
||||
_pending = PendingAction.None;
|
||||
}
|
||||
}
|
||||
|
||||
private static bool IsRateLimited(Exception exception) =>
|
||||
exception is HttpRequestException { StatusCode: HttpStatusCode.TooManyRequests }
|
||||
|| (exception is AggregateException aggregate && aggregate.InnerExceptions.Any(IsRateLimited))
|
||||
|| (exception.InnerException is { } inner && IsRateLimited(inner));
|
||||
|
||||
private async Task OnJoinKeyDownAsync(KeyboardEventArgs args)
|
||||
{
|
||||
if (args.Key == "Enter")
|
||||
{
|
||||
await JoinAsync();
|
||||
}
|
||||
}
|
||||
|
||||
private async Task OnMessageKeyDownAsync(KeyboardEventArgs args)
|
||||
{
|
||||
if (args.Key == "Enter" && (args.CtrlKey || args.MetaKey))
|
||||
{
|
||||
await SendMessageAsync();
|
||||
}
|
||||
}
|
||||
|
||||
private async Task SendMessageAsync()
|
||||
{
|
||||
var text = _message;
|
||||
if (_sendingMessage || string.IsNullOrWhiteSpace(text))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_sendingMessage = true;
|
||||
try
|
||||
{
|
||||
var error = await Session.SendTextAsync(text);
|
||||
if (error is not null)
|
||||
{
|
||||
_error = error;
|
||||
}
|
||||
else if (_message == text)
|
||||
{
|
||||
_message = string.Empty;
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
_sendingMessage = false;
|
||||
}
|
||||
}
|
||||
|
||||
private async Task OnFilesSelectedAsync(InputFileChangeEventArgs args)
|
||||
{
|
||||
_dragging = false;
|
||||
IReadOnlyList<IBrowserFile> files;
|
||||
try
|
||||
{
|
||||
files = args.GetMultipleFiles(MaxFilesPerSelection);
|
||||
}
|
||||
catch (InvalidOperationException)
|
||||
{
|
||||
_error = $"Please select at most {MaxFilesPerSelection} files at once.";
|
||||
return;
|
||||
}
|
||||
|
||||
await Session.SendFilesAsync(files);
|
||||
}
|
||||
|
||||
private async Task CopyCodeAsync()
|
||||
{
|
||||
if (DisplayCode is not { } code)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_copied = await TryCopyAsync(code);
|
||||
if (!_copied)
|
||||
{
|
||||
_error = "Copying failed. Please copy the code manually.";
|
||||
}
|
||||
}
|
||||
|
||||
private async Task CopyEntryAsync(ChatEntry entry)
|
||||
{
|
||||
if (entry.Text is not { } text)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (await TryCopyAsync(text))
|
||||
{
|
||||
_copiedEntry = entry;
|
||||
}
|
||||
else
|
||||
{
|
||||
_error = "Copying failed. Please select and copy the text manually.";
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<bool> TryCopyAsync(string text)
|
||||
{
|
||||
try
|
||||
{
|
||||
using var navigator = JS.Get<Navigator>("navigator");
|
||||
using var clipboard = navigator.Clipboard;
|
||||
await clipboard.WriteText(text);
|
||||
return true;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
Logger.LogWarning(ex, "Copying to the clipboard failed");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private Task DisconnectAsync() => Session.DisconnectAsync();
|
||||
|
||||
private async Task ResetAsync()
|
||||
{
|
||||
_error = null;
|
||||
_copied = false;
|
||||
_copiedEntry = null;
|
||||
_dragging = false;
|
||||
_message = null;
|
||||
await Session.ResetAsync();
|
||||
}
|
||||
|
||||
private void OnSessionChanged()
|
||||
{
|
||||
// Connections opening or closing change the server load, so don't wait for the next poll.
|
||||
if (_session is { } session && session.State != _observedState)
|
||||
{
|
||||
_observedState = session.State;
|
||||
_ = Status.RefreshAsync();
|
||||
}
|
||||
|
||||
RequestRender();
|
||||
}
|
||||
|
||||
private void OnStatusChanged() => RequestRender();
|
||||
|
||||
private void OnTick()
|
||||
{
|
||||
if (_session?.State is SessionState.Waiting or SessionState.Connected)
|
||||
{
|
||||
RequestRender();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Renders right away if the last render is long enough ago, otherwise once <see cref="MinRenderInterval" /> has
|
||||
/// passed; changes in between are coalesced into that render.
|
||||
/// </summary>
|
||||
private void RequestRender()
|
||||
{
|
||||
if (_isRenderScheduled)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_isRenderScheduled = true;
|
||||
var wait = MinRenderInterval - Stopwatch.GetElapsedTime(_lastRenderTimestamp);
|
||||
_ = InvokeAsync(async () =>
|
||||
{
|
||||
if (wait > TimeSpan.Zero)
|
||||
{
|
||||
await Task.Delay(wait);
|
||||
}
|
||||
|
||||
_isRenderScheduled = false;
|
||||
StateHasChanged();
|
||||
});
|
||||
}
|
||||
}
|
||||
783
DataTransfer.Client/Pages/Link.razor.css
Normal file
783
DataTransfer.Client/Pages/Link.razor.css
Normal file
|
|
@ -0,0 +1,783 @@
|
|||
/* ---------- Page heading ---------- */
|
||||
|
||||
.page-head {
|
||||
margin-bottom: 1.25rem;
|
||||
}
|
||||
|
||||
.page-head h1 {
|
||||
font-size: 1.375rem;
|
||||
font-weight: 600;
|
||||
letter-spacing: -0.01em;
|
||||
}
|
||||
|
||||
.page-head p {
|
||||
max-width: 46rem;
|
||||
margin-top: 0.25rem;
|
||||
color: var(--text-muted);
|
||||
}
|
||||
|
||||
/* ---------- Create / join ---------- */
|
||||
|
||||
.connect {
|
||||
display: grid;
|
||||
grid-template-columns: minmax(0, 1fr) auto minmax(0, 1fr);
|
||||
}
|
||||
|
||||
.connect-option {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 0.75rem;
|
||||
padding: 1.5rem;
|
||||
}
|
||||
|
||||
.connect-title {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 0.75rem;
|
||||
font-size: 1rem;
|
||||
font-weight: 600;
|
||||
}
|
||||
|
||||
.connect-icon {
|
||||
display: grid;
|
||||
place-items: center;
|
||||
width: 2rem;
|
||||
height: 2rem;
|
||||
border-radius: var(--radius);
|
||||
background-color: var(--accent-soft);
|
||||
color: var(--accent);
|
||||
}
|
||||
|
||||
.connect-text {
|
||||
flex: 1;
|
||||
color: var(--text-muted);
|
||||
}
|
||||
|
||||
.connect-divider {
|
||||
position: relative;
|
||||
width: 1px;
|
||||
margin: 1.25rem 0;
|
||||
background-color: var(--border);
|
||||
}
|
||||
|
||||
.connect-divider span {
|
||||
position: absolute;
|
||||
top: 50%;
|
||||
left: 50%;
|
||||
padding: 0.25rem 0;
|
||||
transform: translate(-50%, -50%);
|
||||
background-color: var(--surface);
|
||||
color: var(--text-muted);
|
||||
font-size: 0.75rem;
|
||||
letter-spacing: 0.06em;
|
||||
text-transform: uppercase;
|
||||
}
|
||||
|
||||
.join-row {
|
||||
display: flex;
|
||||
gap: 0.5rem;
|
||||
max-width: 26rem;
|
||||
}
|
||||
|
||||
.code-input {
|
||||
font-family: var(--mono);
|
||||
letter-spacing: 0.12em;
|
||||
text-transform: uppercase;
|
||||
}
|
||||
|
||||
.code-input::placeholder {
|
||||
letter-spacing: 0.12em;
|
||||
}
|
||||
|
||||
.steps {
|
||||
display: grid;
|
||||
grid-template-columns: repeat(3, minmax(0, 1fr));
|
||||
gap: 1rem 1.5rem;
|
||||
margin-top: 1.5rem;
|
||||
padding: 0;
|
||||
list-style: none;
|
||||
color: var(--text-muted);
|
||||
font-size: 0.875rem;
|
||||
}
|
||||
|
||||
.steps li {
|
||||
display: flex;
|
||||
gap: 0.75rem;
|
||||
padding-top: 0.75rem;
|
||||
border-top: 2px solid var(--border);
|
||||
}
|
||||
|
||||
.steps strong {
|
||||
display: block;
|
||||
color: var(--text);
|
||||
font-weight: 600;
|
||||
}
|
||||
|
||||
.step-no {
|
||||
color: var(--accent);
|
||||
font-family: var(--mono);
|
||||
font-size: 0.8125rem;
|
||||
font-weight: 600;
|
||||
line-height: 1.6;
|
||||
}
|
||||
|
||||
.capacity-note {
|
||||
display: flex;
|
||||
align-items: flex-start;
|
||||
gap: 0.5rem;
|
||||
padding: 0.5rem 0.75rem;
|
||||
border-radius: var(--radius);
|
||||
background-color: var(--warning-soft);
|
||||
color: var(--warning);
|
||||
font-size: 0.875rem;
|
||||
}
|
||||
|
||||
.capacity-note ::deep .icon {
|
||||
flex: none;
|
||||
width: 1rem;
|
||||
height: 1rem;
|
||||
margin-top: 0.1875rem;
|
||||
}
|
||||
|
||||
/* ---------- Queue ---------- */
|
||||
|
||||
.queue-position {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 1rem;
|
||||
}
|
||||
|
||||
.queue-number {
|
||||
display: grid;
|
||||
place-items: center;
|
||||
min-width: 3.5rem;
|
||||
height: 3.5rem;
|
||||
padding: 0 0.75rem;
|
||||
border: 1px solid var(--border-strong);
|
||||
border-radius: var(--radius);
|
||||
background-color: var(--surface-2);
|
||||
font-family: var(--mono);
|
||||
font-size: 1.75rem;
|
||||
font-weight: 600;
|
||||
font-variant-numeric: tabular-nums;
|
||||
}
|
||||
|
||||
.queue-text {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 0.125rem;
|
||||
}
|
||||
|
||||
.queue-text strong {
|
||||
font-weight: 600;
|
||||
}
|
||||
|
||||
.queue-text .muted {
|
||||
font-size: 0.875rem;
|
||||
}
|
||||
|
||||
/* ---------- Waiting for the peer ---------- */
|
||||
|
||||
.waiting {
|
||||
max-width: 44rem;
|
||||
}
|
||||
|
||||
.waiting-body {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 1.25rem;
|
||||
padding: 1.5rem;
|
||||
}
|
||||
|
||||
.code-display {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
align-items: center;
|
||||
gap: 1rem 1.25rem;
|
||||
}
|
||||
|
||||
.code-chars {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 0.25rem;
|
||||
font-family: var(--mono);
|
||||
user-select: all;
|
||||
}
|
||||
|
||||
.code-char {
|
||||
display: grid;
|
||||
place-items: center;
|
||||
width: 2.25rem;
|
||||
aspect-ratio: 4 / 5;
|
||||
border: 1px solid var(--border-strong);
|
||||
border-radius: var(--radius);
|
||||
background-color: var(--surface-2);
|
||||
font-size: 1.375rem;
|
||||
font-weight: 600;
|
||||
}
|
||||
|
||||
.code-sep {
|
||||
padding: 0 0.25rem;
|
||||
color: var(--text-muted);
|
||||
font-size: 1.25rem;
|
||||
}
|
||||
|
||||
.waiting-status {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
align-items: center;
|
||||
gap: 0.5rem 0.625rem;
|
||||
}
|
||||
|
||||
.waiting-status .spinner {
|
||||
color: var(--accent);
|
||||
}
|
||||
|
||||
.waiting-expiry {
|
||||
margin-left: auto;
|
||||
color: var(--text-muted);
|
||||
font-size: 0.875rem;
|
||||
}
|
||||
|
||||
.countdown {
|
||||
margin-top: -0.75rem;
|
||||
}
|
||||
|
||||
.countdown .progress-bar {
|
||||
transition: width 1s linear;
|
||||
}
|
||||
|
||||
.countdown.is-low .progress-bar {
|
||||
background-color: var(--warning);
|
||||
}
|
||||
|
||||
/* ---------- Session status ---------- */
|
||||
|
||||
.session {
|
||||
margin-bottom: 1rem;
|
||||
}
|
||||
|
||||
.session-main {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
align-items: center;
|
||||
gap: 0.75rem 2rem;
|
||||
padding: 0.875rem 1rem;
|
||||
}
|
||||
|
||||
.session-state {
|
||||
min-width: 8.5rem;
|
||||
font-size: 1rem;
|
||||
}
|
||||
|
||||
.session-facts {
|
||||
display: flex;
|
||||
flex: 1;
|
||||
flex-wrap: wrap;
|
||||
gap: 0.5rem 2.25rem;
|
||||
}
|
||||
|
||||
.session-facts dt {
|
||||
color: var(--text-muted);
|
||||
font-size: 0.6875rem;
|
||||
font-weight: 600;
|
||||
letter-spacing: 0.06em;
|
||||
text-transform: uppercase;
|
||||
}
|
||||
|
||||
.safety-code {
|
||||
font-weight: 600;
|
||||
letter-spacing: 0.03em;
|
||||
}
|
||||
|
||||
.session-hint {
|
||||
display: flex;
|
||||
align-items: flex-start;
|
||||
gap: 0.5rem;
|
||||
padding: 0.5rem 1rem;
|
||||
border-top: 1px solid var(--border);
|
||||
border-radius: 0 0 var(--radius-lg) var(--radius-lg);
|
||||
background-color: var(--surface-2);
|
||||
color: var(--text-muted);
|
||||
font-size: 0.8125rem;
|
||||
}
|
||||
|
||||
.session-hint ::deep .icon {
|
||||
width: 1rem;
|
||||
height: 1rem;
|
||||
margin-top: 0.125rem;
|
||||
color: var(--success);
|
||||
}
|
||||
|
||||
.session-closed {
|
||||
display: flex;
|
||||
flex: 1;
|
||||
flex-direction: column;
|
||||
}
|
||||
|
||||
.session-closed .muted {
|
||||
font-size: 0.8125rem;
|
||||
}
|
||||
|
||||
/* ---------- Workspace ---------- */
|
||||
|
||||
.workspace {
|
||||
display: grid;
|
||||
grid-template-columns: minmax(17rem, 21rem) minmax(0, 1fr);
|
||||
gap: 1rem;
|
||||
align-items: start;
|
||||
}
|
||||
|
||||
.workspace.is-closed {
|
||||
grid-template-columns: minmax(0, 1fr);
|
||||
}
|
||||
|
||||
/* ---------- Send ---------- */
|
||||
|
||||
.send-body {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 1.25rem;
|
||||
}
|
||||
|
||||
.dropzone {
|
||||
position: relative;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
gap: 0.125rem;
|
||||
min-height: 10rem;
|
||||
padding: 1.25rem 1rem;
|
||||
border: 1.5px dashed var(--border-strong);
|
||||
border-radius: var(--radius);
|
||||
background-color: var(--surface-2);
|
||||
color: var(--text-muted);
|
||||
font-size: 0.8125rem;
|
||||
text-align: center;
|
||||
transition: border-color 0.12s, background-color 0.12s;
|
||||
}
|
||||
|
||||
.dropzone strong {
|
||||
color: var(--text);
|
||||
font-size: 0.9375rem;
|
||||
font-weight: 600;
|
||||
}
|
||||
|
||||
.dropzone.is-dragging {
|
||||
border-color: var(--accent);
|
||||
background-color: var(--accent-soft);
|
||||
}
|
||||
|
||||
@media (hover: hover) {
|
||||
.dropzone:not(.is-busy):hover {
|
||||
border-color: var(--accent);
|
||||
background-color: var(--accent-soft);
|
||||
}
|
||||
}
|
||||
|
||||
.dropzone:has(:focus-visible) {
|
||||
border-color: var(--accent);
|
||||
box-shadow: var(--focus-ring);
|
||||
}
|
||||
|
||||
.dropzone.is-busy {
|
||||
border-style: solid;
|
||||
border-color: var(--border);
|
||||
background-color: var(--surface-2);
|
||||
}
|
||||
|
||||
.dropzone-browse {
|
||||
color: var(--accent);
|
||||
text-decoration: underline;
|
||||
text-underline-offset: 2px;
|
||||
}
|
||||
|
||||
.dropzone ::deep .dropzone-icon {
|
||||
width: 1.75rem;
|
||||
height: 1.75rem;
|
||||
margin-bottom: 0.5rem;
|
||||
color: var(--accent);
|
||||
stroke-width: 1.75;
|
||||
}
|
||||
|
||||
.dropzone-spinner {
|
||||
width: 1.5rem;
|
||||
height: 1.5rem;
|
||||
margin-bottom: 0.625rem;
|
||||
color: var(--accent);
|
||||
}
|
||||
|
||||
/* The native file input covers the whole zone, so clicking and dropping both work without JavaScript. */
|
||||
.dropzone ::deep .dropzone-input {
|
||||
position: absolute;
|
||||
inset: 0;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
opacity: 0;
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
.dropzone.is-busy ::deep .dropzone-input {
|
||||
cursor: progress;
|
||||
}
|
||||
|
||||
.send-message {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 0.375rem;
|
||||
}
|
||||
|
||||
.send-actions {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: space-between;
|
||||
gap: 0.5rem;
|
||||
margin-top: 0.25rem;
|
||||
}
|
||||
|
||||
.hint {
|
||||
color: var(--text-muted);
|
||||
font-size: 0.75rem;
|
||||
}
|
||||
|
||||
/* ---------- Transfer log ---------- */
|
||||
|
||||
.log {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
height: min(70vh, 40rem);
|
||||
min-height: 22rem;
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
.log-summary {
|
||||
display: flex;
|
||||
gap: 1rem;
|
||||
color: var(--text-muted);
|
||||
font-size: 0.75rem;
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
.log-summary > span {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
gap: 0.25rem;
|
||||
}
|
||||
|
||||
.log-summary ::deep .icon {
|
||||
width: 0.875rem;
|
||||
height: 0.875rem;
|
||||
}
|
||||
|
||||
.log-scroll {
|
||||
display: flex;
|
||||
flex: 1;
|
||||
flex-direction: column-reverse;
|
||||
overflow-y: auto;
|
||||
}
|
||||
|
||||
.log-entries {
|
||||
/* Keeps short logs at the top while column-reverse anchors the scroll position at the newest entry. */
|
||||
margin-bottom: auto;
|
||||
padding: 0;
|
||||
list-style: none;
|
||||
}
|
||||
|
||||
.log-empty {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
align-items: center;
|
||||
gap: 0.25rem;
|
||||
max-width: 22rem;
|
||||
margin: auto;
|
||||
padding: 2rem 1.5rem;
|
||||
color: var(--text-muted);
|
||||
font-size: 0.875rem;
|
||||
text-align: center;
|
||||
}
|
||||
|
||||
.log-empty strong {
|
||||
color: var(--text);
|
||||
font-size: 0.9375rem;
|
||||
font-weight: 600;
|
||||
}
|
||||
|
||||
.log-empty ::deep .icon {
|
||||
width: 2rem;
|
||||
height: 2rem;
|
||||
margin-bottom: 0.5rem;
|
||||
color: var(--border-strong);
|
||||
stroke-width: 1.5;
|
||||
}
|
||||
|
||||
.entry {
|
||||
display: grid;
|
||||
grid-template-columns: 1.75rem minmax(0, 1fr) auto 5.5rem;
|
||||
grid-template-areas: "dir body meta action";
|
||||
align-items: start;
|
||||
gap: 0.25rem 1rem;
|
||||
padding: 0.625rem 1rem;
|
||||
border-bottom: 1px solid var(--border);
|
||||
}
|
||||
|
||||
@media (hover: hover) {
|
||||
.entry:not(.entry-system):hover {
|
||||
background-color: var(--surface-2);
|
||||
}
|
||||
}
|
||||
|
||||
.entry-dir {
|
||||
grid-area: dir;
|
||||
display: grid;
|
||||
place-items: center;
|
||||
width: 1.75rem;
|
||||
height: 1.75rem;
|
||||
border-radius: var(--radius);
|
||||
}
|
||||
|
||||
.entry-dir ::deep .icon {
|
||||
width: 1rem;
|
||||
height: 1rem;
|
||||
}
|
||||
|
||||
.entry-out .entry-dir {
|
||||
background-color: var(--accent-soft);
|
||||
color: var(--accent);
|
||||
}
|
||||
|
||||
.entry-in .entry-dir {
|
||||
background-color: var(--success-soft);
|
||||
color: var(--success);
|
||||
}
|
||||
|
||||
.entry-body {
|
||||
grid-area: body;
|
||||
min-width: 0;
|
||||
padding-top: 0.1875rem;
|
||||
}
|
||||
|
||||
.entry-file {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 0.5rem;
|
||||
font-weight: 500;
|
||||
}
|
||||
|
||||
.entry-file ::deep .icon {
|
||||
width: 1rem;
|
||||
height: 1rem;
|
||||
color: var(--text-muted);
|
||||
}
|
||||
|
||||
.entry-name {
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
.entry-text {
|
||||
white-space: pre-wrap;
|
||||
overflow-wrap: anywhere;
|
||||
}
|
||||
|
||||
.entry-progress {
|
||||
margin-top: 0.5rem;
|
||||
}
|
||||
|
||||
.entry-error {
|
||||
margin-top: 0.125rem;
|
||||
color: var(--danger);
|
||||
font-size: 0.8125rem;
|
||||
}
|
||||
|
||||
.entry-warning {
|
||||
display: flex;
|
||||
align-items: flex-start;
|
||||
gap: 0.375rem;
|
||||
margin-top: 0.25rem;
|
||||
padding: 0.375rem 0.5rem;
|
||||
border: 1px solid var(--warning);
|
||||
border-radius: var(--radius);
|
||||
background-color: var(--warning-soft);
|
||||
color: var(--text);
|
||||
font-size: 0.8125rem;
|
||||
}
|
||||
|
||||
.entry-warning ::deep .icon {
|
||||
flex: none;
|
||||
width: 1rem;
|
||||
height: 1rem;
|
||||
margin-top: 0.0625rem;
|
||||
color: var(--warning);
|
||||
}
|
||||
|
||||
.entry-meta {
|
||||
grid-area: meta;
|
||||
display: flex;
|
||||
justify-content: flex-end;
|
||||
gap: 1rem;
|
||||
padding-top: 0.3125rem;
|
||||
color: var(--text-muted);
|
||||
font-family: var(--mono);
|
||||
font-size: 0.8125rem;
|
||||
font-variant-numeric: tabular-nums;
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
.entry-size {
|
||||
min-width: 4.75rem;
|
||||
text-align: right;
|
||||
}
|
||||
|
||||
.entry-time {
|
||||
min-width: 3.25rem;
|
||||
text-align: right;
|
||||
}
|
||||
|
||||
.entry-action {
|
||||
grid-area: action;
|
||||
display: flex;
|
||||
justify-content: flex-end;
|
||||
padding-top: 0.125rem;
|
||||
}
|
||||
|
||||
.entry-action .tag {
|
||||
margin-top: 0.0625rem;
|
||||
}
|
||||
|
||||
.entry-system {
|
||||
grid-template-columns: 1.75rem minmax(0, 1fr) auto;
|
||||
grid-template-areas: "dir body meta";
|
||||
background-color: var(--surface-2);
|
||||
color: var(--text-muted);
|
||||
font-size: 0.875rem;
|
||||
}
|
||||
|
||||
.entry-system.is-error {
|
||||
background-color: var(--danger-soft);
|
||||
color: var(--danger);
|
||||
}
|
||||
|
||||
/* ---------- Small screens ---------- */
|
||||
|
||||
@media (max-width: 860px) {
|
||||
.workspace {
|
||||
grid-template-columns: minmax(0, 1fr);
|
||||
}
|
||||
|
||||
.log {
|
||||
height: auto;
|
||||
min-height: 16rem;
|
||||
max-height: 70vh;
|
||||
}
|
||||
}
|
||||
|
||||
@media (max-width: 720px) {
|
||||
.connect {
|
||||
grid-template-columns: minmax(0, 1fr);
|
||||
}
|
||||
|
||||
.connect-option {
|
||||
padding: 1.25rem;
|
||||
}
|
||||
|
||||
.connect-divider {
|
||||
width: auto;
|
||||
height: 1px;
|
||||
margin: 0 1.25rem;
|
||||
}
|
||||
|
||||
.connect-divider span {
|
||||
padding: 0 0.5rem;
|
||||
}
|
||||
|
||||
.join-row {
|
||||
max-width: none;
|
||||
}
|
||||
|
||||
.steps {
|
||||
grid-template-columns: minmax(0, 1fr);
|
||||
}
|
||||
|
||||
.waiting-body {
|
||||
padding: 1.25rem 1rem;
|
||||
}
|
||||
|
||||
.code-chars {
|
||||
gap: 0.1875rem;
|
||||
}
|
||||
|
||||
.code-char {
|
||||
width: clamp(1.5rem, 6.8vw, 2.25rem);
|
||||
font-size: clamp(1rem, 4.6vw, 1.375rem);
|
||||
}
|
||||
|
||||
.code-sep {
|
||||
padding: 0 0.125rem;
|
||||
}
|
||||
|
||||
.waiting-expiry {
|
||||
margin-left: 0;
|
||||
flex-basis: 100%;
|
||||
}
|
||||
|
||||
.session-main {
|
||||
gap: 0.75rem 1.5rem;
|
||||
}
|
||||
|
||||
.session-facts {
|
||||
flex-basis: 100%;
|
||||
order: 1;
|
||||
gap: 0.5rem 1.5rem;
|
||||
}
|
||||
|
||||
.session-closed {
|
||||
flex-basis: 100%;
|
||||
order: 1;
|
||||
}
|
||||
|
||||
.session-state {
|
||||
flex: 1;
|
||||
}
|
||||
}
|
||||
|
||||
@media (max-width: 560px) {
|
||||
.entry {
|
||||
grid-template-columns: 1.75rem minmax(0, 1fr) auto;
|
||||
grid-template-areas:
|
||||
"dir body action"
|
||||
"dir meta action";
|
||||
column-gap: 0.75rem;
|
||||
padding: 0.625rem 0.75rem;
|
||||
}
|
||||
|
||||
.entry-system {
|
||||
grid-template-areas:
|
||||
"dir body"
|
||||
"dir meta";
|
||||
grid-template-columns: 1.75rem minmax(0, 1fr);
|
||||
}
|
||||
|
||||
.entry-meta {
|
||||
justify-content: flex-start;
|
||||
gap: 0.75rem;
|
||||
padding-top: 0;
|
||||
font-size: 0.75rem;
|
||||
}
|
||||
|
||||
.entry-size,
|
||||
.entry-time {
|
||||
min-width: 0;
|
||||
text-align: left;
|
||||
}
|
||||
|
||||
.entry-size:empty {
|
||||
display: none;
|
||||
}
|
||||
|
||||
.entry-action {
|
||||
align-self: center;
|
||||
padding-top: 0;
|
||||
}
|
||||
}
|
||||
15
DataTransfer.Client/Program.cs
Normal file
15
DataTransfer.Client/Program.cs
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
using DataTransfer.Client.Services;
|
||||
using Microsoft.AspNetCore.Components.WebAssembly.Hosting;
|
||||
using SpawnDev.BlazorJS;
|
||||
using SpawnDev.BlazorJS.Cryptography;
|
||||
|
||||
var builder = WebAssemblyHostBuilder.CreateDefault(args);
|
||||
|
||||
builder.Services.AddBlazorJSRuntime();
|
||||
builder.Services.AddSingleton<PortableCrypto, BrowserWASMCrypto>();
|
||||
builder.Services.AddSingleton<BotCheckSolver>();
|
||||
builder.Services.AddSingleton(services => new ServerStatusMonitor(
|
||||
new HttpClient { BaseAddress = new Uri(builder.HostEnvironment.BaseAddress) },
|
||||
services.GetRequiredService<ILogger<ServerStatusMonitor>>()));
|
||||
|
||||
await builder.Build().BlazorJSRunAsync();
|
||||
21
DataTransfer.Client/Services/BotCheckSolver.cs
Normal file
21
DataTransfer.Client/Services/BotCheckSolver.cs
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
using DataTransfer.Client.Shared;
|
||||
using Microsoft.AspNetCore.Components;
|
||||
using Microsoft.JSInterop;
|
||||
|
||||
namespace DataTransfer.Client.Services;
|
||||
|
||||
/// <summary>Solves the server's proof-of-work bot check in web workers (<c>wwwroot/js/bot-check.js</c> of the server).</summary>
|
||||
public sealed class BotCheckSolver(IJSRuntime js, NavigationManager navigation)
|
||||
{
|
||||
/// <returns>The solution, or <c>-1</c> if none was found.</returns>
|
||||
public async Task<int> SolveAsync(BotCheckChallenge challenge)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(challenge);
|
||||
|
||||
// An absolute URL, so the module resolves relative to the app's base URI under any path base.
|
||||
await using var module = await js.InvokeAsync<IJSObjectReference>(
|
||||
"import",
|
||||
navigation.ToAbsoluteUri("js/bot-check.js").ToString());
|
||||
return await module.InvokeAsync<int>("solve", challenge.Salt, challenge.Hash, challenge.MaxNumber);
|
||||
}
|
||||
}
|
||||
36
DataTransfer.Client/Services/ChatEntry.cs
Normal file
36
DataTransfer.Client/Services/ChatEntry.cs
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
namespace DataTransfer.Client.Services;
|
||||
|
||||
public enum ChatEntryKind
|
||||
{
|
||||
Incoming,
|
||||
Outgoing,
|
||||
System
|
||||
}
|
||||
|
||||
public sealed class ChatEntry
|
||||
{
|
||||
public DateTimeOffset Time { get; } = DateTimeOffset.Now;
|
||||
|
||||
public bool IsFile => FileName is not null;
|
||||
|
||||
public bool IsTransferring => IsFile && Error is null && TransferredBytes < FileSize;
|
||||
|
||||
public int ProgressPercent => FileSize == 0 ? 100 : (int)(TransferredBytes * 100 / FileSize);
|
||||
public required ChatEntryKind Kind { get; init; }
|
||||
|
||||
public string? Text { get; init; }
|
||||
|
||||
public string? FileName { get; init; }
|
||||
|
||||
public long FileSize { get; init; }
|
||||
|
||||
public long TransferredBytes { get; set; }
|
||||
|
||||
/// <summary>Object URL of a completely received and decrypted file.</summary>
|
||||
public string? DownloadUrl { get; set; }
|
||||
|
||||
/// <summary>A received file whose type can run code or is often used for malware or phishing.</summary>
|
||||
public bool IsRiskyFile { get; init; }
|
||||
|
||||
public string? Error { get; set; }
|
||||
}
|
||||
32
DataTransfer.Client/Services/DisplayFormat.cs
Normal file
32
DataTransfer.Client/Services/DisplayFormat.cs
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
using System.Globalization;
|
||||
|
||||
namespace DataTransfer.Client.Services;
|
||||
|
||||
public static class DisplayFormat
|
||||
{
|
||||
public static string Bytes(long bytes) => bytes switch
|
||||
{
|
||||
>= 1024L * 1024 * 1024 => string.Create(CultureInfo.InvariantCulture, $"{bytes / 1024d / 1024d / 1024d:0.#} GB"),
|
||||
>= 1024 * 1024 => string.Create(CultureInfo.InvariantCulture, $"{bytes / 1024d / 1024d:0.0} MB"),
|
||||
>= 1024 => string.Create(CultureInfo.InvariantCulture, $"{bytes / 1024d:0.0} KB"),
|
||||
_ => $"{bytes} B"
|
||||
};
|
||||
|
||||
public static string Duration(TimeSpan duration) =>
|
||||
duration switch
|
||||
{
|
||||
{ TotalHours: >= 1, Minutes: 0, Seconds: 0 } => string.Create(CultureInfo.InvariantCulture, $"{duration.TotalHours:0} h"),
|
||||
{ TotalMinutes: >= 1, Seconds: 0 } => string.Create(CultureInfo.InvariantCulture, $"{duration.TotalMinutes:0} min"),
|
||||
_ => string.Create(CultureInfo.InvariantCulture, $"{duration.TotalSeconds:0} s")
|
||||
};
|
||||
|
||||
public static string Countdown(TimeSpan remaining)
|
||||
{
|
||||
if (remaining < TimeSpan.Zero)
|
||||
{
|
||||
remaining = TimeSpan.Zero;
|
||||
}
|
||||
|
||||
return remaining.ToString(remaining.TotalHours >= 1 ? @"h\:mm\:ss" : @"mm\:ss", CultureInfo.InvariantCulture);
|
||||
}
|
||||
}
|
||||
54
DataTransfer.Client/Services/FileNameSanitizer.cs
Normal file
54
DataTransfer.Client/Services/FileNameSanitizer.cs
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
using System.Globalization;
|
||||
using System.Text;
|
||||
|
||||
namespace DataTransfer.Client.Services;
|
||||
|
||||
public static class FileNameSanitizer
|
||||
{
|
||||
private const int MaxLength = 255;
|
||||
private const string Fallback = "file";
|
||||
|
||||
// Characters invalid in file names on Windows, macOS or Linux. Path.GetInvalidFileNameChars() returns only the
|
||||
// Unix set in WebAssembly, but the file is saved on any operating system.
|
||||
private const string InvalidCharacters = "<>:\"/\\|?*";
|
||||
|
||||
/// <summary>
|
||||
/// Makes a file name received from the peer safe to display and save. Invisible formatting characters are removed,
|
||||
/// so for example a right-to-left override can't disguise <c>invoice‮fdp.exe</c> as <c>invoiceexe.pdf</c>.
|
||||
/// </summary>
|
||||
public static string Sanitize(string? name)
|
||||
{
|
||||
if (string.IsNullOrEmpty(name))
|
||||
{
|
||||
return Fallback;
|
||||
}
|
||||
|
||||
var builder = new StringBuilder(Math.Min(name.Length, MaxLength));
|
||||
foreach (var rune in name.EnumerateRunes())
|
||||
{
|
||||
switch (Rune.GetUnicodeCategory(rune))
|
||||
{
|
||||
case UnicodeCategory.Format:
|
||||
continue;
|
||||
case UnicodeCategory.Control:
|
||||
Append(builder, new Rune('_'));
|
||||
continue;
|
||||
}
|
||||
|
||||
Append(builder, rune.IsAscii && InvalidCharacters.Contains((char)rune.Value) ? new Rune('_') : rune);
|
||||
}
|
||||
|
||||
// Windows silently drops trailing dots and spaces, which could change the extension.
|
||||
var cleaned = builder.ToString().Trim().TrimEnd('.');
|
||||
return cleaned.Length == 0 ? Fallback : cleaned;
|
||||
}
|
||||
|
||||
// Appends whole runes only, so truncation never splits a surrogate pair.
|
||||
private static void Append(StringBuilder builder, Rune rune)
|
||||
{
|
||||
if (builder.Length + rune.Utf16SequenceLength <= MaxLength)
|
||||
{
|
||||
builder.Append(rune.ToString());
|
||||
}
|
||||
}
|
||||
}
|
||||
101
DataTransfer.Client/Services/Frames.cs
Normal file
101
DataTransfer.Client/Services/Frames.cs
Normal file
|
|
@ -0,0 +1,101 @@
|
|||
using System.Text;
|
||||
|
||||
namespace DataTransfer.Client.Services;
|
||||
|
||||
/// <summary>Application frames. They are encrypted as a whole, so the relay server cannot see their type or content.</summary>
|
||||
public abstract record Frame;
|
||||
|
||||
public sealed record TextFrame(string Text) : Frame;
|
||||
|
||||
public sealed record FileStartFrame(int FileId, string Name, long Size) : Frame;
|
||||
|
||||
public sealed record FileChunkFrame(int FileId, ReadOnlyMemory<byte> Data) : Frame;
|
||||
|
||||
public sealed record FileCancelFrame(int FileId) : Frame;
|
||||
|
||||
/// <summary>Plaintext layout: version (byte) | type (byte) | sequence number (int64) | type-specific body.</summary>
|
||||
internal static class FrameCodec
|
||||
{
|
||||
private const byte Version = 1;
|
||||
|
||||
private enum FrameType : byte
|
||||
{
|
||||
Text = 1,
|
||||
FileStart = 2,
|
||||
FileChunk = 3,
|
||||
FileCancel = 4
|
||||
}
|
||||
|
||||
public static byte[] Encode(long sequence, Frame frame)
|
||||
{
|
||||
var capacity = frame is FileChunkFrame chunk ? chunk.Data.Length + 32 : 256;
|
||||
using var stream = new MemoryStream(capacity);
|
||||
using (var writer = new BinaryWriter(stream, Encoding.UTF8, true))
|
||||
{
|
||||
writer.Write(Version);
|
||||
switch (frame)
|
||||
{
|
||||
case TextFrame text:
|
||||
WriteHeader(writer, FrameType.Text, sequence);
|
||||
writer.Write(text.Text);
|
||||
break;
|
||||
case FileStartFrame start:
|
||||
WriteHeader(writer, FrameType.FileStart, sequence);
|
||||
writer.Write(start.FileId);
|
||||
writer.Write(start.Name);
|
||||
writer.Write(start.Size);
|
||||
break;
|
||||
case FileChunkFrame fileChunk:
|
||||
WriteHeader(writer, FrameType.FileChunk, sequence);
|
||||
writer.Write(fileChunk.FileId);
|
||||
writer.Write(fileChunk.Data.Span);
|
||||
break;
|
||||
case FileCancelFrame cancel:
|
||||
WriteHeader(writer, FrameType.FileCancel, sequence);
|
||||
writer.Write(cancel.FileId);
|
||||
break;
|
||||
default:
|
||||
throw new ArgumentOutOfRangeException(nameof(frame), frame, "Unknown frame.");
|
||||
}
|
||||
}
|
||||
|
||||
return stream.ToArray();
|
||||
}
|
||||
|
||||
/// <exception cref="InvalidDataException">The plaintext is not a valid frame.</exception>
|
||||
public static (long Sequence, Frame Frame) Decode(byte[] plaintext)
|
||||
{
|
||||
try
|
||||
{
|
||||
using var reader = new BinaryReader(new MemoryStream(plaintext, false), Encoding.UTF8);
|
||||
if (reader.ReadByte() != Version)
|
||||
{
|
||||
throw new InvalidDataException("Unsupported frame version.");
|
||||
}
|
||||
|
||||
var type = (FrameType)reader.ReadByte();
|
||||
var sequence = reader.ReadInt64();
|
||||
Frame frame = type switch
|
||||
{
|
||||
FrameType.Text => new TextFrame(reader.ReadString()),
|
||||
FrameType.FileStart => new FileStartFrame(reader.ReadInt32(), reader.ReadString(), reader.ReadInt64()),
|
||||
FrameType.FileChunk => new FileChunkFrame(reader.ReadInt32(), plaintext.AsMemory((int)reader.BaseStream.Position)),
|
||||
FrameType.FileCancel => new FileCancelFrame(reader.ReadInt32()),
|
||||
_ => throw new InvalidDataException("Unknown frame type.")
|
||||
};
|
||||
|
||||
return (sequence, frame);
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or FormatException)
|
||||
{
|
||||
// EndOfStreamException (truncated), IOException (negative string length), FormatException (bad 7-bit length).
|
||||
throw new InvalidDataException("Malformed frame.", ex);
|
||||
}
|
||||
}
|
||||
|
||||
private static void WriteHeader(BinaryWriter writer, FrameType type, long sequence)
|
||||
{
|
||||
writer.Write((byte)type);
|
||||
writer.Write(sequence);
|
||||
}
|
||||
}
|
||||
53
DataTransfer.Client/Services/HandshakeCodec.cs
Normal file
53
DataTransfer.Client/Services/HandshakeCodec.cs
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
namespace DataTransfer.Client.Services;
|
||||
|
||||
/// <summary>
|
||||
/// Plaintext messages of the commit-then-reveal key exchange (see <see cref="SecureChannel" />). They are relayed
|
||||
/// like frames, but before the channel is encrypted. Layout: version (byte) | type (byte) | payload.
|
||||
/// </summary>
|
||||
internal static class HandshakeCodec
|
||||
{
|
||||
public const int CommitmentBytes = 32;
|
||||
|
||||
// A P-256 SPKI key has 91 bytes; anything much larger is not a key.
|
||||
private const int MaxPublicKeyBytes = 512;
|
||||
private const byte Version = 1;
|
||||
|
||||
private enum MessageType : byte
|
||||
{
|
||||
Commitment = 1,
|
||||
PublicKey = 2
|
||||
}
|
||||
|
||||
public static byte[] EncodeCommitment(byte[] commitment) => Encode(MessageType.Commitment, commitment);
|
||||
|
||||
public static byte[] EncodePublicKey(byte[] publicKey) => Encode(MessageType.PublicKey, publicKey);
|
||||
|
||||
/// <exception cref="InvalidDataException">The message is not a commitment.</exception>
|
||||
public static byte[] DecodeCommitment(byte[] message) =>
|
||||
Decode(message, MessageType.Commitment, CommitmentBytes, CommitmentBytes);
|
||||
|
||||
/// <exception cref="InvalidDataException">The message is not a public key.</exception>
|
||||
public static byte[] DecodePublicKey(byte[] message) => Decode(message, MessageType.PublicKey, 1, MaxPublicKeyBytes);
|
||||
|
||||
private static byte[] Encode(MessageType type, byte[] payload)
|
||||
{
|
||||
var message = new byte[payload.Length + 2];
|
||||
message[0] = Version;
|
||||
message[1] = (byte)type;
|
||||
payload.CopyTo(message, 2);
|
||||
return message;
|
||||
}
|
||||
|
||||
private static byte[] Decode(byte[] message, MessageType type, int minPayloadBytes, int maxPayloadBytes)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(message);
|
||||
|
||||
var payloadBytes = message.Length - 2;
|
||||
if (payloadBytes < minPayloadBytes || payloadBytes > maxPayloadBytes || message[0] != Version || message[1] != (byte)type)
|
||||
{
|
||||
throw new InvalidDataException($"Expected a valid key-exchange message of type {type}.");
|
||||
}
|
||||
|
||||
return message[2..];
|
||||
}
|
||||
}
|
||||
40
DataTransfer.Client/Services/RiskyFileTypes.cs
Normal file
40
DataTransfer.Client/Services/RiskyFileTypes.cs
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
using System.Collections.Frozen;
|
||||
|
||||
namespace DataTransfer.Client.Services;
|
||||
|
||||
/// <summary>
|
||||
/// File types that can run code when opened, or are commonly used to deliver malware or phishing. Common archives
|
||||
/// (zip, 7z, rar) and documents are deliberately not listed, so the warning stays meaningful.
|
||||
/// </summary>
|
||||
public static class RiskyFileTypes
|
||||
{
|
||||
private static readonly FrozenSet<string> Extensions = new[]
|
||||
{
|
||||
// Windows programs and installers
|
||||
"exe", "com", "scr", "pif", "cpl", "msi", "msix", "msixbundle", "msp", "appx", "appxbundle", "appref-ms",
|
||||
"application", "gadget", "dll", "sys", "drv", "ocx",
|
||||
|
||||
// Scripts
|
||||
"bat", "cmd", "ps1", "psm1", "vbs", "vbe", "js", "jse", "mjs", "wsf", "wsh", "wsc", "sct", "hta", "jar", "py",
|
||||
"pyw", "sh", "bash", "command", "applescript", "scpt", "reg", "inf", "msc",
|
||||
|
||||
// Shortcuts and shell files that can launch programs
|
||||
"lnk", "url", "scf", "library-ms", "search-ms", "settingcontent-ms",
|
||||
|
||||
// macOS and Linux applications and packages
|
||||
"app", "pkg", "mpkg", "dmg", "workflow", "action", "deb", "rpm", "appimage", "run", "bin",
|
||||
|
||||
// Disk images, often used to bypass download protection
|
||||
"iso", "img", "vhd", "vhdx",
|
||||
|
||||
// Office documents with macros, add-ins and other formats abused for malware
|
||||
"docm", "dotm", "xlsm", "xltm", "xlam", "xll", "pptm", "potm", "ppam", "ppsm", "sldm", "one", "chm",
|
||||
|
||||
// Web pages opened from disk, a common way to deliver phishing
|
||||
"htm", "html", "xhtml", "mht", "mhtml"
|
||||
}.ToFrozenSet(StringComparer.OrdinalIgnoreCase);
|
||||
|
||||
/// <summary>Only the last extension counts, so <c>invoice.pdf.exe</c> is risky and <c>setup.exe.txt</c> is not.</summary>
|
||||
public static bool IsRisky(string? fileName) =>
|
||||
Path.GetExtension(fileName) is { Length: > 1 } extension && Extensions.Contains(extension[1..]);
|
||||
}
|
||||
264
DataTransfer.Client/Services/SecureChannel.cs
Normal file
264
DataTransfer.Client/Services/SecureChannel.cs
Normal file
|
|
@ -0,0 +1,264 @@
|
|||
using System.Globalization;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
using SpawnDev.BlazorJS.Cryptography;
|
||||
using static SpawnDev.BlazorJS.Cryptography.PortableCrypto;
|
||||
|
||||
namespace DataTransfer.Client.Services;
|
||||
|
||||
/// <summary>
|
||||
/// End-to-end encryption of one connection. Runs in the browser (WebAssembly + WebCrypto); keys never leave it.
|
||||
/// <list type="bullet">
|
||||
/// <item>
|
||||
/// Key agreement: ephemeral ECDH P-256; the private key is non-extractable and discarded after the
|
||||
/// agreement.
|
||||
/// </item>
|
||||
/// <item>
|
||||
/// Commit-then-reveal: the joiner first sends a hash commitment to its public key, the creator then reveals
|
||||
/// its key, and only afterwards the joiner reveals its key, which the creator checks against the commitment.
|
||||
/// A relay in the middle therefore has to fix the keys it shows each side before it learns the real keys, and
|
||||
/// can't search for keys that produce matching safety codes.
|
||||
/// </item>
|
||||
/// <item>
|
||||
/// One AES-256-GCM key per direction (PBKDF2-SHA-256 over the shared secret, salted with direction, code and
|
||||
/// both public keys), so a frame can't be reflected back to its sender.
|
||||
/// </item>
|
||||
/// <item>
|
||||
/// Every frame carries a sequence number inside the ciphertext: replayed, reordered or dropped frames are
|
||||
/// rejected.
|
||||
/// </item>
|
||||
/// <item>
|
||||
/// The safety code is a hash of both public keys; if both users see the same code, nobody intercepted the
|
||||
/// agreement.
|
||||
/// </item>
|
||||
/// </list>
|
||||
/// </summary>
|
||||
public sealed class SecureChannel : IDisposable
|
||||
{
|
||||
private const string Protocol = "DataTransfer/v3";
|
||||
private const int KeyDerivationIterations = 10_000;
|
||||
|
||||
private readonly PortableCrypto _crypto;
|
||||
private PortableECDHKey? _keyPair;
|
||||
private PortableAESGCMKey? _sendKey;
|
||||
private PortableAESGCMKey? _receiveKey;
|
||||
private long _sendSequence;
|
||||
private long _receiveSequence;
|
||||
|
||||
private SecureChannel(PortableCrypto crypto, PortableECDHKey keyPair, byte[] publicKey, byte[] commitment)
|
||||
{
|
||||
_crypto = crypto;
|
||||
_keyPair = keyPair;
|
||||
PublicKey = publicKey;
|
||||
Commitment = commitment;
|
||||
}
|
||||
|
||||
/// <summary>Ephemeral ECDH public key (SPKI) to send to the peer.</summary>
|
||||
public byte[] PublicKey { get; }
|
||||
|
||||
/// <summary>Hash commitment to <see cref="PublicKey" />; the joiner sends it before revealing its key.</summary>
|
||||
public byte[] Commitment { get; }
|
||||
|
||||
public bool IsEstablished => _sendKey is not null;
|
||||
|
||||
public static async Task<SecureChannel> CreateAsync(PortableCrypto crypto)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(crypto);
|
||||
|
||||
var keyPair = await crypto.GenerateECDHKey(NamedCurve.P256, false);
|
||||
try
|
||||
{
|
||||
var publicKey = await crypto.ExportPublicKeySpki(keyPair);
|
||||
var commitment = await ComputeCommitmentAsync(crypto, publicKey);
|
||||
return new SecureChannel(crypto, keyPair, publicKey, commitment);
|
||||
}
|
||||
catch
|
||||
{
|
||||
keyPair.Dispose();
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Completes the key agreement as creator and returns the safety code both users can compare.
|
||||
/// </summary>
|
||||
/// <param name="joinerCommitment">The commitment the joiner sent before the creator revealed its key.</param>
|
||||
/// <exception cref="CryptographicException">The joiner's key does not match its commitment.</exception>
|
||||
public async Task<string> EstablishAsCreatorAsync(byte[] joinerPublicKey, byte[] joinerCommitment, string code)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(joinerPublicKey);
|
||||
ArgumentNullException.ThrowIfNull(joinerCommitment);
|
||||
|
||||
var expected = await ComputeCommitmentAsync(_crypto, joinerPublicKey);
|
||||
if (!CryptographicOperations.FixedTimeEquals(expected, joinerCommitment))
|
||||
{
|
||||
throw new CryptographicException("The peer's public key does not match its commitment.");
|
||||
}
|
||||
|
||||
return await EstablishAsync(joinerPublicKey, true, code);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Completes the key agreement as joiner and returns the safety code. Must only be called after
|
||||
/// <see cref="Commitment" /> was sent, and <see cref="PublicKey" /> must only be revealed afterwards.
|
||||
/// </summary>
|
||||
public Task<string> EstablishAsJoinerAsync(byte[] creatorPublicKey, string code) =>
|
||||
EstablishAsync(creatorPublicKey, false, code);
|
||||
|
||||
/// <summary>Encrypts the next outgoing frame. Callers must send sealed frames in the order they were sealed.</summary>
|
||||
public Task<byte[]> SealAsync(Frame frame)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(frame);
|
||||
|
||||
var key = _sendKey ?? throw new InvalidOperationException("The channel is not established.");
|
||||
return _crypto.Encrypt(key, FrameCodec.Encode(++_sendSequence, frame));
|
||||
}
|
||||
|
||||
/// <summary>Decrypts and verifies the next incoming frame.</summary>
|
||||
/// <exception cref="CryptographicException">The frame was tampered with, replayed, reordered or dropped.</exception>
|
||||
public async Task<Frame> OpenAsync(byte[] ciphertext)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(ciphertext);
|
||||
|
||||
var key = _receiveKey ?? throw new InvalidOperationException("The channel is not established.");
|
||||
|
||||
byte[]? plaintext;
|
||||
try
|
||||
{
|
||||
plaintext = await _crypto.Decrypt(key, ciphertext);
|
||||
}
|
||||
catch (Exception ex) when (ex is not OperationCanceledException)
|
||||
{
|
||||
throw new CryptographicException("The frame could not be decrypted.", ex);
|
||||
}
|
||||
|
||||
if (plaintext is null)
|
||||
{
|
||||
throw new CryptographicException("The frame could not be decrypted.");
|
||||
}
|
||||
|
||||
long sequence;
|
||||
Frame frame;
|
||||
try
|
||||
{
|
||||
(sequence, frame) = FrameCodec.Decode(plaintext);
|
||||
}
|
||||
catch (InvalidDataException ex)
|
||||
{
|
||||
throw new CryptographicException("The frame is malformed.", ex);
|
||||
}
|
||||
|
||||
if (sequence != _receiveSequence + 1)
|
||||
{
|
||||
throw new CryptographicException("A frame was replayed, reordered or dropped.");
|
||||
}
|
||||
|
||||
_receiveSequence = sequence;
|
||||
return frame;
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
_keyPair?.Dispose();
|
||||
_sendKey?.Dispose();
|
||||
_receiveKey?.Dispose();
|
||||
_keyPair = null;
|
||||
_sendKey = null;
|
||||
_receiveKey = null;
|
||||
}
|
||||
|
||||
private static async Task<byte[]> ComputeCommitmentAsync(PortableCrypto crypto, byte[] publicKey) =>
|
||||
await crypto.Digest(HashName.SHA256, Concat(Encoding.UTF8.GetBytes($"{Protocol}|commitment|"), publicKey));
|
||||
|
||||
private static string FormatSafetyCode(byte[] digest)
|
||||
{
|
||||
var groups = new string[4];
|
||||
for (var group = 0; group < groups.Length; group++)
|
||||
{
|
||||
ulong value = 0;
|
||||
for (var i = 0; i < 5; i++)
|
||||
{
|
||||
value = (value << 8) | digest[group * 5 + i];
|
||||
}
|
||||
|
||||
groups[group] = (value % 100_000).ToString("D5", CultureInfo.InvariantCulture);
|
||||
}
|
||||
|
||||
return string.Join(' ', groups);
|
||||
}
|
||||
|
||||
private static byte[] Concat(params byte[][] parts)
|
||||
{
|
||||
var result = new byte[parts.Sum(part => part.Length)];
|
||||
var offset = 0;
|
||||
foreach (var part in parts)
|
||||
{
|
||||
part.CopyTo(result, offset);
|
||||
offset += part.Length;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private async Task<string> EstablishAsync(byte[] peerPublicKey, bool isCreator, string code)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(peerPublicKey);
|
||||
ArgumentException.ThrowIfNullOrEmpty(code);
|
||||
|
||||
var keyPair = _keyPair;
|
||||
if (keyPair is null || IsEstablished)
|
||||
{
|
||||
throw new InvalidOperationException("The channel can only be established once.");
|
||||
}
|
||||
|
||||
if (peerPublicKey.AsSpan().SequenceEqual(PublicKey))
|
||||
{
|
||||
throw new CryptographicException("The peer presented our own public key.");
|
||||
}
|
||||
|
||||
_keyPair = null;
|
||||
byte[]? sharedSecret = null;
|
||||
try
|
||||
{
|
||||
using var peerKey = await _crypto.ImportECDHKey(peerPublicKey, NamedCurve.P256);
|
||||
sharedSecret = await _crypto.DeriveBits(keyPair, peerKey, 256);
|
||||
|
||||
var creatorKey = isCreator ? PublicKey : peerPublicKey;
|
||||
var joinerKey = isCreator ? peerPublicKey : PublicKey;
|
||||
var creatorToJoiner = await DeriveKeyAsync(sharedSecret, "creator->joiner", code, creatorKey, joinerKey);
|
||||
var joinerToCreator = await DeriveKeyAsync(sharedSecret, "joiner->creator", code, creatorKey, joinerKey);
|
||||
|
||||
_sendKey = isCreator ? creatorToJoiner : joinerToCreator;
|
||||
_receiveKey = isCreator ? joinerToCreator : creatorToJoiner;
|
||||
|
||||
var digest = await _crypto.Digest(HashName.SHA256, Concat(Encoding.UTF8.GetBytes($"{Protocol}|safety-code|"), creatorKey, joinerKey));
|
||||
return FormatSafetyCode(digest);
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (sharedSecret is not null)
|
||||
{
|
||||
CryptographicOperations.ZeroMemory(sharedSecret);
|
||||
}
|
||||
|
||||
keyPair.Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<PortableAESGCMKey> DeriveKeyAsync(byte[] sharedSecret, string direction, string code, byte[] creatorKey, byte[] joinerKey)
|
||||
{
|
||||
var salt = await _crypto.Digest(
|
||||
HashName.SHA256,
|
||||
Concat(Encoding.UTF8.GetBytes($"{Protocol}|{direction}|{code}|"), creatorKey, joinerKey));
|
||||
|
||||
return await _crypto.GenerateAESGCMKey(
|
||||
sharedSecret,
|
||||
salt,
|
||||
KeyDerivationIterations,
|
||||
HashName.SHA256,
|
||||
32,
|
||||
16,
|
||||
12,
|
||||
false);
|
||||
}
|
||||
}
|
||||
63
DataTransfer.Client/Services/ServerStatusMonitor.cs
Normal file
63
DataTransfer.Client/Services/ServerStatusMonitor.cs
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
using System.Net.Http.Json;
|
||||
using DataTransfer.Client.Shared;
|
||||
|
||||
namespace DataTransfer.Client.Services;
|
||||
|
||||
/// <summary>Periodically fetches the load of the relay server; shared by all components of the page.</summary>
|
||||
public sealed class ServerStatusMonitor(HttpClient http, ILogger<ServerStatusMonitor> logger) : IDisposable
|
||||
{
|
||||
private static readonly TimeSpan PollInterval = TimeSpan.FromSeconds(5);
|
||||
|
||||
private readonly CancellationTokenSource _stopping = new();
|
||||
private Task? _polling;
|
||||
|
||||
public event Action? Changed;
|
||||
|
||||
/// <summary>The latest status, or <c>null</c> while it is unknown.</summary>
|
||||
public ServerStatus? Current { get; private set; }
|
||||
|
||||
public void EnsureStarted() => _polling ??= PollAsync(_stopping.Token);
|
||||
|
||||
public async Task RefreshAsync(CancellationToken cancellationToken = default)
|
||||
{
|
||||
ServerStatus? status;
|
||||
try
|
||||
{
|
||||
status = await http.GetFromJsonAsync<ServerStatus>(TransferProtocol.StatusPath.TrimStart('/'), cancellationToken);
|
||||
}
|
||||
catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
|
||||
{
|
||||
return;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
logger.LogDebug(ex, "Fetching the server status failed");
|
||||
status = null;
|
||||
}
|
||||
|
||||
if (status != Current)
|
||||
{
|
||||
Current = status;
|
||||
Changed?.Invoke();
|
||||
}
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
_stopping.Cancel();
|
||||
_stopping.Dispose();
|
||||
}
|
||||
|
||||
private async Task PollAsync(CancellationToken cancellationToken)
|
||||
{
|
||||
using var timer = new PeriodicTimer(PollInterval);
|
||||
try
|
||||
{
|
||||
do
|
||||
{
|
||||
await RefreshAsync(cancellationToken);
|
||||
} while (await timer.WaitForNextTickAsync(cancellationToken));
|
||||
}
|
||||
catch (OperationCanceledException) { }
|
||||
}
|
||||
}
|
||||
973
DataTransfer.Client/Services/TransferSession.cs
Normal file
973
DataTransfer.Client/Services/TransferSession.cs
Normal file
|
|
@ -0,0 +1,973 @@
|
|||
using System.Security.Cryptography;
|
||||
using DataTransfer.Client.Shared;
|
||||
using Microsoft.AspNetCore.Components;
|
||||
using Microsoft.AspNetCore.Components.Forms;
|
||||
using Microsoft.AspNetCore.SignalR.Client;
|
||||
using SpawnDev.BlazorJS.Cryptography;
|
||||
using SpawnDev.BlazorJS.JSObjects;
|
||||
|
||||
namespace DataTransfer.Client.Services;
|
||||
|
||||
public enum SessionState
|
||||
{
|
||||
Idle,
|
||||
|
||||
/// <summary>The server is at its connection limit; the connection is created once a slot becomes free.</summary>
|
||||
Queued,
|
||||
Joining,
|
||||
Waiting,
|
||||
Connected,
|
||||
Closed
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// One end of a transfer connection, running in the browser. Pairs via the relay hub, exchanges keys with the
|
||||
/// commit-then-reveal protocol of <see cref="SecureChannel" />, encrypts everything afterwards and keeps the decrypted
|
||||
/// chat history locally. Plaintext never leaves the browser.
|
||||
/// </summary>
|
||||
public sealed class TransferSession(
|
||||
NavigationManager navigation,
|
||||
PortableCrypto crypto,
|
||||
BotCheckSolver botCheckSolver,
|
||||
ILogger<TransferSession> logger) : IAsyncDisposable
|
||||
{
|
||||
private const string KeyExchangeFailedMessage = "The secure key exchange failed. Please start a new connection.";
|
||||
|
||||
private const string TooManyConnectionsMessage =
|
||||
"Your network already has the maximum number of open connections on this server. Please close other transfers or try again later.";
|
||||
|
||||
private const string TransferLimitMessage = "The connection was closed because it reached its transfer limit.";
|
||||
|
||||
private static readonly string ReceiveLimitMessage =
|
||||
$"The connection was closed because the other person sent more than {TransferProtocol.MaxItemsPerConnection:N0} " +
|
||||
$"messages and files or more than {DisplayFormat.Bytes(TransferProtocol.MaxFileBytesPerConnection)} in total.";
|
||||
|
||||
private static readonly string SendLimitMessage =
|
||||
$"This connection can transfer at most {TransferProtocol.MaxItemsPerConnection:N0} messages and files " +
|
||||
$"and {DisplayFormat.Bytes(TransferProtocol.MaxFileBytesPerConnection)} in total. Please start a new connection.";
|
||||
|
||||
// The creator's browser answers the joiner's commitment immediately; waiting longer means it's gone or misbehaving.
|
||||
private static readonly TimeSpan KeyExchangeTimeout = TimeSpan.FromSeconds(30);
|
||||
|
||||
private readonly List<ChatEntry> _entries = [];
|
||||
private readonly Dictionary<int, IncomingFile> _incomingFiles = [];
|
||||
private readonly List<string> _objectUrls = [];
|
||||
private readonly SemaphoreSlim _sendLock = new(1, 1);
|
||||
|
||||
private HubConnection? _hub;
|
||||
private SecureChannel? _channel;
|
||||
private KeyExchangeStep _keyExchange;
|
||||
private byte[]? _peerCommitment;
|
||||
private bool _peerJoined;
|
||||
private TaskCompletionSource _keyExchangeCompleted = CreateCompletionSource();
|
||||
private DateTimeOffset _lastActivity;
|
||||
private int _nextFileId;
|
||||
|
||||
// Per-connection totals, limited by TransferProtocol.MaxItemsPerConnection and MaxFileBytesPerConnection.
|
||||
private int _sentItems;
|
||||
private long _sentFileBytes;
|
||||
private int _receivedItems;
|
||||
private long _receivedFileBytes;
|
||||
|
||||
/// <summary>Steps of the commit-then-reveal key exchange; see <see cref="SecureChannel" />.</summary>
|
||||
private enum KeyExchangeStep
|
||||
{
|
||||
None,
|
||||
|
||||
/// <summary>Creator: waits for the joiner's commitment to its public key.</summary>
|
||||
AwaitingCommitment,
|
||||
|
||||
/// <summary>Creator: revealed its public key and waits for the joiner's.</summary>
|
||||
AwaitingJoinerKey,
|
||||
|
||||
/// <summary>Joiner: committed to its public key and waits for the creator's.</summary>
|
||||
AwaitingCreatorKey,
|
||||
|
||||
Completed
|
||||
}
|
||||
|
||||
public event Action? Changed;
|
||||
|
||||
public IReadOnlyList<ChatEntry> Entries => _entries;
|
||||
|
||||
public TimeSpan InactivityTimeout { get; private set; }
|
||||
|
||||
/// <summary>A new code expires unless someone joins within this period.</summary>
|
||||
public TimeSpan JoinTimeout { get; private set; }
|
||||
|
||||
/// <summary>The timeout <see cref="RemainingTime" /> counts down: joining for a fresh code, inactivity afterwards.</summary>
|
||||
public TimeSpan CountdownDuration =>
|
||||
State == SessionState.Waiting && !_peerJoined ? JoinTimeout : InactivityTimeout;
|
||||
|
||||
/// <summary>Time until the server removes the connection unless someone joins or something is transmitted.</summary>
|
||||
public TimeSpan? RemainingTime => State is SessionState.Waiting or SessionState.Connected
|
||||
? _lastActivity + CountdownDuration - DateTimeOffset.UtcNow
|
||||
: null;
|
||||
|
||||
public SessionState State { get; private set; }
|
||||
|
||||
/// <summary>The normalized connection code.</summary>
|
||||
public string? Code { get; private set; }
|
||||
|
||||
public string? SafetyCode { get; private set; }
|
||||
|
||||
public string? ClosedMessage { get; private set; }
|
||||
|
||||
/// <summary>1-based position in the server's queue while <see cref="SessionState.Queued" />.</summary>
|
||||
public int QueuePosition { get; private set; }
|
||||
|
||||
public bool HasPeer { get; private set; }
|
||||
|
||||
/// <summary>Someone joined the creator's connection and the key exchange is in progress.</summary>
|
||||
public bool IsPeerJoining => State == SessionState.Waiting && _peerJoined;
|
||||
|
||||
public bool IsSendingFiles { get; private set; }
|
||||
|
||||
/// <summary>The browser is solving the server's bot check before the connection is created.</summary>
|
||||
public bool IsVerifyingBrowser { get; private set; }
|
||||
|
||||
/// <returns>An error message for the user, or <c>null</c>.</returns>
|
||||
public async Task<string?> CreateAsync()
|
||||
{
|
||||
var (hub, _) = await StartAsync();
|
||||
var botCheckSolution = await SolveBotCheckAsync(hub);
|
||||
if (!IsCurrent(hub))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var result = await hub.InvokeAsync<CreateConnectionResult>(nameof(ITransferHub.CreateConnection), botCheckSolution);
|
||||
|
||||
// A ConnectionCreated message may have overtaken this result and already admitted the queued request.
|
||||
if (!IsCurrent(hub) || State != SessionState.Idle)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
switch (result)
|
||||
{
|
||||
case { Status: CreateStatus.Created, Code: not null }:
|
||||
Admit(result);
|
||||
return null;
|
||||
|
||||
case { Status: CreateStatus.Queued }:
|
||||
UpdateQueuePosition(result.QueuePosition);
|
||||
State = SessionState.Queued;
|
||||
NotifyChanged();
|
||||
return null;
|
||||
|
||||
case { Status: CreateStatus.TooManyConnections }:
|
||||
await ResetAsync();
|
||||
return TooManyConnectionsMessage;
|
||||
|
||||
case { Status: CreateStatus.BotCheckFailed }:
|
||||
await ResetAsync();
|
||||
return "The automatic check against bots failed. Please try again.";
|
||||
|
||||
default:
|
||||
await ResetAsync();
|
||||
return "The server is at its connection limit and the queue is full. Please try again later.";
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Joins a connection and completes the key exchange.</summary>
|
||||
/// <returns>An error message for the user, or <c>null</c>.</returns>
|
||||
public async Task<string?> JoinAsync(string? input)
|
||||
{
|
||||
if (!ConnectionCode.TryNormalize(input, out var code))
|
||||
{
|
||||
return $"Please enter a valid {ConnectionCode.Length}-character code.";
|
||||
}
|
||||
|
||||
var (hub, channel) = await StartAsync();
|
||||
var keyExchangeCompleted = _keyExchangeCompleted.Task;
|
||||
Code = code;
|
||||
State = SessionState.Joining;
|
||||
NotifyChanged();
|
||||
|
||||
var result = await hub.InvokeAsync<JoinConnectionResult>(nameof(ITransferHub.JoinConnection), code);
|
||||
if (!IsCurrent(hub) || State != SessionState.Joining)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
if (result.Status != JoinStatus.Joined)
|
||||
{
|
||||
await ResetAsync();
|
||||
return result.Status switch
|
||||
{
|
||||
JoinStatus.InvalidCode => $"Please enter a valid {ConnectionCode.Length}-character code.",
|
||||
JoinStatus.AlreadyInUse => "This connection already has two participants.",
|
||||
JoinStatus.TooManyConnections => TooManyConnectionsMessage,
|
||||
_ => "No open connection with this code exists. It may have expired."
|
||||
};
|
||||
}
|
||||
|
||||
InactivityTimeout = result.InactivityTimeout;
|
||||
|
||||
// Commit to our key before the creator reveals its key; ours is revealed only after receiving it.
|
||||
_keyExchange = KeyExchangeStep.AwaitingCreatorKey;
|
||||
if (!await SendKeyExchangeMessageAsync(hub, HandshakeCodec.EncodeCommitment(channel.Commitment)))
|
||||
{
|
||||
await CloseAsync(hub, KeyExchangeFailedMessage);
|
||||
return null;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
// Completed by OnReceiveAsync once the creator's key arrived and ours was revealed.
|
||||
await keyExchangeCompleted.WaitAsync(KeyExchangeTimeout);
|
||||
}
|
||||
catch (TimeoutException)
|
||||
{
|
||||
await CloseAsync(hub, "The other person did not respond. Please ask for a new code.");
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
// Closed or reset meanwhile; the closed message tells the user why.
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/// <returns>An error message for the user, or <c>null</c>.</returns>
|
||||
public async Task<string?> SendTextAsync(string? text)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(text))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
if (text.Length > TransferProtocol.MaxMessageLength)
|
||||
{
|
||||
return "The message is too long.";
|
||||
}
|
||||
|
||||
if (_sentItems >= TransferProtocol.MaxItemsPerConnection)
|
||||
{
|
||||
return SendLimitMessage;
|
||||
}
|
||||
|
||||
var error = await SendFrameAsync(new TextFrame(text));
|
||||
if (error is null)
|
||||
{
|
||||
_sentItems++;
|
||||
AddEntry(
|
||||
new ChatEntry
|
||||
{
|
||||
Kind = ChatEntryKind.Outgoing,
|
||||
Text = text
|
||||
});
|
||||
}
|
||||
|
||||
NotifyChanged();
|
||||
return error;
|
||||
}
|
||||
|
||||
public async Task SendFilesAsync(IReadOnlyList<IBrowserFile> files)
|
||||
{
|
||||
if (State != SessionState.Connected || IsSendingFiles || files.Count == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
IsSendingFiles = true;
|
||||
NotifyChanged();
|
||||
try
|
||||
{
|
||||
foreach (var file in files)
|
||||
{
|
||||
if (State != SessionState.Connected)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
if (file.Size > TransferProtocol.MaxFileBytes)
|
||||
{
|
||||
AddSystemEntry($"\"{file.Name}\" is too large (max. {DisplayFormat.Bytes(TransferProtocol.MaxFileBytes)}).", true);
|
||||
continue;
|
||||
}
|
||||
|
||||
// The peer closes the connection beyond these limits, so stop before reaching them.
|
||||
if (_sentItems >= TransferProtocol.MaxItemsPerConnection
|
||||
|| _sentFileBytes + file.Size > TransferProtocol.MaxFileBytesPerConnection)
|
||||
{
|
||||
AddSystemEntry(SendLimitMessage, true);
|
||||
break;
|
||||
}
|
||||
|
||||
var entry = new ChatEntry
|
||||
{
|
||||
Kind = ChatEntryKind.Outgoing,
|
||||
FileName = file.Name,
|
||||
FileSize = file.Size
|
||||
};
|
||||
AddEntry(entry);
|
||||
NotifyChanged();
|
||||
|
||||
var error = await SendFileAsync(file, entry);
|
||||
if (error is not null)
|
||||
{
|
||||
entry.Error = error;
|
||||
}
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
IsSendingFiles = false;
|
||||
NotifyChanged();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Leaves the connection but keeps the chat history visible.</summary>
|
||||
public async Task DisconnectAsync()
|
||||
{
|
||||
if (_hub is not { } hub || State is not (SessionState.Waiting or SessionState.Connected))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
MarkClosed("You closed the connection.");
|
||||
try
|
||||
{
|
||||
await hub.InvokeAsync(nameof(ITransferHub.LeaveConnection));
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
// Includes the cancellation when a reset disposes the hub meanwhile.
|
||||
logger.LogDebug(ex, "Leaving the connection failed");
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Leaves any connection, forgets keys and history and returns to <see cref="SessionState.Idle" />.</summary>
|
||||
public async Task ResetAsync()
|
||||
{
|
||||
var hub = _hub;
|
||||
_hub = null;
|
||||
_keyExchangeCompleted.TrySetCanceled();
|
||||
_keyExchangeCompleted = CreateCompletionSource();
|
||||
_keyExchange = KeyExchangeStep.None;
|
||||
_peerCommitment = null;
|
||||
_peerJoined = false;
|
||||
_channel?.Dispose();
|
||||
_channel = null;
|
||||
|
||||
_incomingFiles.Clear();
|
||||
_entries.Clear();
|
||||
RevokeObjectUrls();
|
||||
|
||||
State = SessionState.Idle;
|
||||
Code = null;
|
||||
SafetyCode = null;
|
||||
ClosedMessage = null;
|
||||
QueuePosition = 0;
|
||||
HasPeer = false;
|
||||
IsVerifyingBrowser = false;
|
||||
_nextFileId = 0;
|
||||
_sentItems = 0;
|
||||
_sentFileBytes = 0;
|
||||
_receivedItems = 0;
|
||||
_receivedFileBytes = 0;
|
||||
|
||||
if (hub is not null)
|
||||
{
|
||||
try
|
||||
{
|
||||
// Disconnecting makes the server close the connection and notify the peer.
|
||||
await hub.DisposeAsync();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
logger.LogDebug(ex, "Disposing the hub connection failed");
|
||||
}
|
||||
}
|
||||
|
||||
NotifyChanged();
|
||||
}
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
Changed = null;
|
||||
await ResetAsync();
|
||||
}
|
||||
|
||||
private static TaskCompletionSource CreateCompletionSource() => new(TaskCreationOptions.RunContinuationsAsynchronously);
|
||||
|
||||
/// <summary>Proof of work against creating connections in bulk; see <see cref="BotCheckChallenge" />.</summary>
|
||||
/// <returns>The solution, or <c>-1</c> if the server doesn't require the check.</returns>
|
||||
private async Task<int> SolveBotCheckAsync(HubConnection hub)
|
||||
{
|
||||
var challenge = await hub.InvokeAsync<BotCheckChallenge?>(nameof(ITransferHub.GetBotCheckChallenge));
|
||||
if (challenge is null || !IsCurrent(hub))
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
IsVerifyingBrowser = true;
|
||||
NotifyChanged();
|
||||
try
|
||||
{
|
||||
return await botCheckSolver.SolveAsync(challenge);
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (IsCurrent(hub))
|
||||
{
|
||||
IsVerifyingBrowser = false;
|
||||
NotifyChanged();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<(HubConnection Hub, SecureChannel Channel)> StartAsync()
|
||||
{
|
||||
await ResetAsync();
|
||||
|
||||
var channel = await SecureChannel.CreateAsync(crypto);
|
||||
var hub = new HubConnectionBuilder()
|
||||
// Relative to the base URI like all other requests, so the app also works under a path base.
|
||||
.WithUrl(navigation.ToAbsoluteUri(TransferProtocol.HubPath.TrimStart('/')))
|
||||
.Build();
|
||||
|
||||
// SignalR invokes these handlers one after another, in the order the server sent the messages.
|
||||
hub.On(nameof(ITransferHubClient.PeerJoined), () => OnPeerJoined(hub));
|
||||
hub.On<byte[]>(nameof(ITransferHubClient.Receive), frame => OnReceiveAsync(hub, frame));
|
||||
hub.On<ConnectionClosedReason>(nameof(ITransferHubClient.ConnectionClosed), reason => OnConnectionClosed(hub, reason));
|
||||
hub.On<CreateConnectionResult>(nameof(ITransferHubClient.ConnectionCreated), result => OnConnectionCreated(hub, result));
|
||||
hub.On<int>(nameof(ITransferHubClient.QueuePositionChanged), position => OnQueuePositionChanged(hub, position));
|
||||
hub.Closed += error => OnHubClosed(hub, error);
|
||||
|
||||
_hub = hub;
|
||||
_channel = channel;
|
||||
try
|
||||
{
|
||||
await hub.StartAsync();
|
||||
}
|
||||
catch
|
||||
{
|
||||
await ResetAsync();
|
||||
throw;
|
||||
}
|
||||
|
||||
return (hub, channel);
|
||||
}
|
||||
|
||||
private void OnPeerJoined(HubConnection hub)
|
||||
{
|
||||
if (IsCurrent(hub) && State == SessionState.Waiting)
|
||||
{
|
||||
// The server counts the join as activity, so the countdown switches to the inactivity timeout.
|
||||
_peerJoined = true;
|
||||
Touch();
|
||||
NotifyChanged();
|
||||
}
|
||||
}
|
||||
|
||||
private async Task OnReceiveAsync(HubConnection hub, byte[] frame)
|
||||
{
|
||||
if (!IsCurrent(hub) || _channel is not { } channel)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (_keyExchange != KeyExchangeStep.Completed)
|
||||
{
|
||||
await ContinueKeyExchangeAsync(hub, channel, frame);
|
||||
return;
|
||||
}
|
||||
|
||||
if (State != SessionState.Connected)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
var decrypted = await channel.OpenAsync(frame);
|
||||
if (!IsCurrent(hub) || State != SessionState.Connected)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Touch();
|
||||
if (ExceedsReceiveLimits(decrypted))
|
||||
{
|
||||
logger.LogWarning("The peer exceeded the per-connection limits");
|
||||
await CloseAsync(hub, ReceiveLimitMessage);
|
||||
}
|
||||
else
|
||||
{
|
||||
Handle(decrypted);
|
||||
}
|
||||
}
|
||||
catch (Exception ex) when (ex is CryptographicException or InvalidDataException)
|
||||
{
|
||||
if (!IsCurrent(hub) || State != SessionState.Connected)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
logger.LogWarning(ex, "Rejected an incoming frame");
|
||||
AddSystemEntry("Received data failed verification and was discarded.", true);
|
||||
await CloseAsync(hub, "The connection was closed because received data failed verification.");
|
||||
}
|
||||
|
||||
NotifyChanged();
|
||||
}
|
||||
|
||||
/// <summary>Handles the plaintext key-exchange messages that precede all encrypted frames.</summary>
|
||||
private async Task ContinueKeyExchangeAsync(HubConnection hub, SecureChannel channel, byte[] message)
|
||||
{
|
||||
try
|
||||
{
|
||||
switch (_keyExchange)
|
||||
{
|
||||
case KeyExchangeStep.AwaitingCommitment when State == SessionState.Waiting:
|
||||
{
|
||||
_peerCommitment = HandshakeCodec.DecodeCommitment(message);
|
||||
_peerJoined = true;
|
||||
_keyExchange = KeyExchangeStep.AwaitingJoinerKey;
|
||||
NotifyChanged();
|
||||
|
||||
// The joiner is bound to its key now, so ours can be revealed.
|
||||
if (!await SendKeyExchangeMessageAsync(hub, HandshakeCodec.EncodePublicKey(channel.PublicKey)))
|
||||
{
|
||||
await CloseAsync(hub, KeyExchangeFailedMessage);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case KeyExchangeStep.AwaitingJoinerKey
|
||||
when State == SessionState.Waiting && _peerCommitment is { } commitment && Code is { } code:
|
||||
{
|
||||
var joinerKey = HandshakeCodec.DecodePublicKey(message);
|
||||
var safetyCode = await channel.EstablishAsCreatorAsync(joinerKey, commitment, code);
|
||||
CompleteKeyExchange(hub, safetyCode);
|
||||
break;
|
||||
}
|
||||
|
||||
case KeyExchangeStep.AwaitingCreatorKey when State == SessionState.Joining && Code is { } code:
|
||||
{
|
||||
var creatorKey = HandshakeCodec.DecodePublicKey(message);
|
||||
var safetyCode = await channel.EstablishAsJoinerAsync(creatorKey, code);
|
||||
if (!IsCurrent(hub) || State != SessionState.Joining)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
// Revealed only now that the creator's key is fixed.
|
||||
if (!await SendKeyExchangeMessageAsync(hub, HandshakeCodec.EncodePublicKey(channel.PublicKey)))
|
||||
{
|
||||
await CloseAsync(hub, KeyExchangeFailedMessage);
|
||||
break;
|
||||
}
|
||||
|
||||
CompleteKeyExchange(hub, safetyCode);
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
throw new InvalidDataException("Unexpected key-exchange message.");
|
||||
}
|
||||
}
|
||||
catch (Exception ex) when (ex is not OperationCanceledException)
|
||||
{
|
||||
logger.LogWarning(ex, "The key exchange failed");
|
||||
await CloseAsync(hub, KeyExchangeFailedMessage);
|
||||
}
|
||||
}
|
||||
|
||||
private void CompleteKeyExchange(HubConnection hub, string safetyCode)
|
||||
{
|
||||
if (!IsCurrent(hub) || State is not (SessionState.Waiting or SessionState.Joining))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
SafetyCode = safetyCode;
|
||||
_keyExchange = KeyExchangeStep.Completed;
|
||||
_peerCommitment = null;
|
||||
HasPeer = true;
|
||||
State = SessionState.Connected;
|
||||
Touch();
|
||||
_keyExchangeCompleted.TrySetResult();
|
||||
NotifyChanged();
|
||||
}
|
||||
|
||||
private Task OnConnectionClosed(HubConnection hub, ConnectionClosedReason reason)
|
||||
{
|
||||
if (IsCurrent(hub) && State is SessionState.Joining or SessionState.Waiting or SessionState.Connected)
|
||||
{
|
||||
var inactivity = DisplayFormat.Duration(InactivityTimeout);
|
||||
MarkClosed(
|
||||
reason switch
|
||||
{
|
||||
ConnectionClosedReason.Inactivity when State == SessionState.Waiting && !_peerJoined =>
|
||||
$"The code expired because nobody joined within {DisplayFormat.Duration(JoinTimeout)}.",
|
||||
ConnectionClosedReason.Inactivity => $"The connection was closed because nothing was sent for {inactivity}.",
|
||||
ConnectionClosedReason.MaximumLifetime => "The connection was closed because it reached its maximum duration.",
|
||||
ConnectionClosedReason.TransferLimitReached => TransferLimitMessage,
|
||||
_ when !HasPeer => "The other person left before the connection was established.",
|
||||
_ => "The other person closed the connection."
|
||||
});
|
||||
}
|
||||
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
// Idle covers messages that arrive while the CreateConnection result is still on its way.
|
||||
private Task OnConnectionCreated(HubConnection hub, CreateConnectionResult result)
|
||||
{
|
||||
if (IsCurrent(hub) && State is SessionState.Idle or SessionState.Queued && result is { Status: CreateStatus.Created, Code: not null })
|
||||
{
|
||||
Admit(result);
|
||||
}
|
||||
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
private Task OnQueuePositionChanged(HubConnection hub, int position)
|
||||
{
|
||||
if (IsCurrent(hub) && State is SessionState.Idle or SessionState.Queued && position > 0)
|
||||
{
|
||||
UpdateQueuePosition(position);
|
||||
NotifyChanged();
|
||||
}
|
||||
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
private void Admit(CreateConnectionResult result)
|
||||
{
|
||||
Code = result.Code;
|
||||
JoinTimeout = result.JoinTimeout;
|
||||
InactivityTimeout = result.InactivityTimeout;
|
||||
QueuePosition = 0;
|
||||
_keyExchange = KeyExchangeStep.AwaitingCommitment;
|
||||
Touch();
|
||||
State = SessionState.Waiting;
|
||||
NotifyChanged();
|
||||
}
|
||||
|
||||
// The position only ever decreases, so an older value that arrives late must not move the client back.
|
||||
private void UpdateQueuePosition(int position) =>
|
||||
QueuePosition = QueuePosition == 0 ? position : Math.Min(QueuePosition, position);
|
||||
|
||||
private Task OnHubClosed(HubConnection hub, Exception? error)
|
||||
{
|
||||
if (IsCurrent(hub) && State is SessionState.Queued or SessionState.Joining or SessionState.Waiting or SessionState.Connected)
|
||||
{
|
||||
logger.LogWarning(error, "Lost the connection to the server");
|
||||
MarkClosed(
|
||||
State == SessionState.Queued
|
||||
? "The connection to the server was lost while waiting in the queue."
|
||||
: "The connection to the server was lost.");
|
||||
}
|
||||
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Everything received stays in memory until the session is reset, so a peer must not be able to make this
|
||||
/// browser keep an unbounded number of entries or files.
|
||||
/// </summary>
|
||||
private bool ExceedsReceiveLimits(Frame frame) => frame switch
|
||||
{
|
||||
TextFrame => _receivedItems >= TransferProtocol.MaxItemsPerConnection,
|
||||
FileStartFrame start => _receivedItems >= TransferProtocol.MaxItemsPerConnection
|
||||
|| _receivedFileBytes + Math.Max(start.Size, 0) > TransferProtocol.MaxFileBytesPerConnection,
|
||||
_ => false
|
||||
};
|
||||
|
||||
private void Handle(Frame frame)
|
||||
{
|
||||
switch (frame)
|
||||
{
|
||||
case TextFrame text:
|
||||
if (text.Text.Length > TransferProtocol.MaxMessageLength)
|
||||
{
|
||||
throw new InvalidDataException("The message is too long.");
|
||||
}
|
||||
|
||||
_receivedItems++;
|
||||
AddEntry(
|
||||
new ChatEntry
|
||||
{
|
||||
Kind = ChatEntryKind.Incoming,
|
||||
Text = text.Text
|
||||
});
|
||||
break;
|
||||
|
||||
case FileStartFrame start:
|
||||
// Senders transmit one file at a time; this also bounds the memory a peer can make us allocate.
|
||||
if (start.Size is < 0 or > TransferProtocol.MaxFileBytes || _incomingFiles.Count > 0)
|
||||
{
|
||||
throw new InvalidDataException("Invalid file announcement.");
|
||||
}
|
||||
|
||||
_receivedItems++;
|
||||
_receivedFileBytes += start.Size;
|
||||
var fileName = FileNameSanitizer.Sanitize(start.Name);
|
||||
var entry = new ChatEntry
|
||||
{
|
||||
Kind = ChatEntryKind.Incoming,
|
||||
FileName = fileName,
|
||||
FileSize = start.Size,
|
||||
IsRiskyFile = RiskyFileTypes.IsRisky(fileName)
|
||||
};
|
||||
AddEntry(entry);
|
||||
|
||||
var incoming = new IncomingFile(entry, new byte[start.Size]);
|
||||
if (start.Size == 0)
|
||||
{
|
||||
CompleteFile(incoming);
|
||||
}
|
||||
else
|
||||
{
|
||||
_incomingFiles.Add(start.FileId, incoming);
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case FileChunkFrame chunk:
|
||||
if (!_incomingFiles.TryGetValue(chunk.FileId, out var file)
|
||||
|| chunk.Data.Length == 0
|
||||
|| chunk.Data.Length > file.Buffer.Length - file.Entry.TransferredBytes)
|
||||
{
|
||||
throw new InvalidDataException("Unexpected file chunk.");
|
||||
}
|
||||
|
||||
chunk.Data.Span.CopyTo(file.Buffer.AsSpan((int)file.Entry.TransferredBytes));
|
||||
file.Entry.TransferredBytes += chunk.Data.Length;
|
||||
if (file.Entry.TransferredBytes == file.Buffer.Length)
|
||||
{
|
||||
_incomingFiles.Remove(chunk.FileId);
|
||||
CompleteFile(file);
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case FileCancelFrame cancel:
|
||||
if (_incomingFiles.Remove(cancel.FileId, out var cancelled))
|
||||
{
|
||||
cancelled.Entry.Error = "The sender cancelled the transfer.";
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private void CompleteFile(IncomingFile file)
|
||||
{
|
||||
try
|
||||
{
|
||||
// Always offered as a download (octet-stream); never rendered inline in this origin.
|
||||
using var blob = new Blob(new[] { file.Buffer }, new BlobOptions { Type = "application/octet-stream" });
|
||||
var url = URL.CreateObjectURL(blob);
|
||||
_objectUrls.Add(url);
|
||||
file.Entry.DownloadUrl = url;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
logger.LogError(ex, "Preparing a received file for download failed");
|
||||
file.Entry.Error = "The file could not be prepared for download.";
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<string?> SendFileAsync(IBrowserFile file, ChatEntry entry)
|
||||
{
|
||||
var fileId = ++_nextFileId;
|
||||
var error = await SendFrameAsync(new FileStartFrame(fileId, file.Name, file.Size));
|
||||
if (error is not null)
|
||||
{
|
||||
return error;
|
||||
}
|
||||
|
||||
// Counted like the receiver does: the announced size, even if the transfer is cancelled later.
|
||||
_sentItems++;
|
||||
_sentFileBytes += file.Size;
|
||||
|
||||
try
|
||||
{
|
||||
await using var stream = file.OpenReadStream(TransferProtocol.MaxFileBytes);
|
||||
var buffer = new byte[TransferProtocol.FileChunkBytes];
|
||||
while (entry.TransferredBytes < file.Size)
|
||||
{
|
||||
var expected = (int)Math.Min(buffer.Length, file.Size - entry.TransferredBytes);
|
||||
var read = await stream.ReadAtLeastAsync(buffer.AsMemory(0, expected), expected, false);
|
||||
if (read != expected)
|
||||
{
|
||||
throw new IOException("The file changed while it was being sent.");
|
||||
}
|
||||
|
||||
error = await SendFrameAsync(new FileChunkFrame(fileId, buffer.AsMemory(0, read)));
|
||||
if (error is not null)
|
||||
{
|
||||
return error;
|
||||
}
|
||||
|
||||
entry.TransferredBytes += read;
|
||||
NotifyChanged();
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
// SendFrameAsync never throws, so this only covers reading the file (including browser errors).
|
||||
logger.LogWarning(ex, "Reading a file failed");
|
||||
await SendFrameAsync(new FileCancelFrame(fileId));
|
||||
return "The file could not be read.";
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Seals and sends one frame. Serialized, so frames reach the peer in sequence-number order. Never throws.
|
||||
/// </summary>
|
||||
/// <returns>An error message for the user, or <c>null</c>.</returns>
|
||||
private async Task<string?> SendFrameAsync(Frame frame)
|
||||
{
|
||||
await _sendLock.WaitAsync();
|
||||
try
|
||||
{
|
||||
if (State != SessionState.Connected || _hub is not { } hub || _channel is not { } channel)
|
||||
{
|
||||
return "The connection is closed.";
|
||||
}
|
||||
|
||||
return await SealAndSendAsync(hub, channel, frame);
|
||||
}
|
||||
finally
|
||||
{
|
||||
_sendLock.Release();
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<string?> SealAndSendAsync(HubConnection hub, SecureChannel channel, Frame frame)
|
||||
{
|
||||
SendStatus status;
|
||||
try
|
||||
{
|
||||
var sealedFrame = await channel.SealAsync(frame);
|
||||
status = await hub.InvokeAsync<SendStatus>(nameof(ITransferHub.Send), sealedFrame);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
// Also covers the cancellation of pending invocations when a reset disposes the hub.
|
||||
if (!IsCurrent(hub))
|
||||
{
|
||||
return "The connection is closed.";
|
||||
}
|
||||
|
||||
logger.LogWarning(ex, "Sending a frame failed");
|
||||
await CloseAsync(hub, "The connection was closed because sending failed.");
|
||||
return "Sending failed.";
|
||||
}
|
||||
|
||||
if (status == SendStatus.Delivered)
|
||||
{
|
||||
Touch();
|
||||
return null;
|
||||
}
|
||||
|
||||
// A sealed but unsent frame leaves a gap in the sequence numbers, so the channel can't be used anymore.
|
||||
await CloseAsync(hub, status == SendStatus.TransferLimitReached ? TransferLimitMessage : "The connection was closed.");
|
||||
return status switch
|
||||
{
|
||||
SendStatus.InvalidSize => "The data is too large.",
|
||||
SendStatus.TransferLimitReached => "The transfer limit of this connection was reached.",
|
||||
_ => "The connection is closed."
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>Sends a plaintext key-exchange message; only public data is sent this way.</summary>
|
||||
private async Task<bool> SendKeyExchangeMessageAsync(HubConnection hub, byte[] message)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (await hub.InvokeAsync<SendStatus>(nameof(ITransferHub.Send), message) != SendStatus.Delivered)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
Touch();
|
||||
return true;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
logger.LogDebug(ex, "Sending a key-exchange message failed");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Closes locally and asks the server to close the connection for the peer, without awaiting a response.</summary>
|
||||
private async Task CloseAsync(HubConnection hub, string message)
|
||||
{
|
||||
if (!IsCurrent(hub) || State is SessionState.Idle or SessionState.Closed)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
MarkClosed(message);
|
||||
try
|
||||
{
|
||||
await hub.SendAsync(nameof(ITransferHub.LeaveConnection));
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
logger.LogDebug(ex, "Leaving the connection failed");
|
||||
}
|
||||
}
|
||||
|
||||
private void MarkClosed(string message)
|
||||
{
|
||||
State = SessionState.Closed;
|
||||
ClosedMessage = message;
|
||||
_keyExchangeCompleted.TrySetCanceled();
|
||||
|
||||
foreach (var file in _incomingFiles.Values)
|
||||
{
|
||||
file.Entry.Error ??= "The transfer was interrupted.";
|
||||
}
|
||||
|
||||
_incomingFiles.Clear();
|
||||
NotifyChanged();
|
||||
}
|
||||
|
||||
private bool IsCurrent(HubConnection hub) => ReferenceEquals(_hub, hub);
|
||||
|
||||
private void Touch() => _lastActivity = DateTimeOffset.UtcNow;
|
||||
|
||||
private void AddEntry(ChatEntry entry) => _entries.Add(entry);
|
||||
|
||||
private void AddSystemEntry(string text, bool isError) =>
|
||||
_entries.Add(
|
||||
new ChatEntry
|
||||
{
|
||||
Kind = ChatEntryKind.System,
|
||||
Text = text,
|
||||
Error = isError ? text : null
|
||||
});
|
||||
|
||||
private void NotifyChanged() => Changed?.Invoke();
|
||||
|
||||
private void RevokeObjectUrls()
|
||||
{
|
||||
foreach (var url in _objectUrls)
|
||||
{
|
||||
try
|
||||
{
|
||||
URL.RevokeObjectURL(url);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
logger.LogDebug(ex, "Revoking an object URL failed");
|
||||
}
|
||||
}
|
||||
|
||||
_objectUrls.Clear();
|
||||
}
|
||||
|
||||
private sealed record IncomingFile(ChatEntry Entry, byte[] Buffer);
|
||||
}
|
||||
54
DataTransfer.Client/Shared/ConnectionCode.cs
Normal file
54
DataTransfer.Client/Shared/ConnectionCode.cs
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
using System.Diagnostics.CodeAnalysis;
|
||||
using System.Security.Cryptography;
|
||||
|
||||
namespace DataTransfer.Client.Shared;
|
||||
|
||||
/// <summary>Generates and parses the one-time codes used to pair two participants.</summary>
|
||||
public static class ConnectionCode
|
||||
{
|
||||
public const int Length = 10;
|
||||
|
||||
// Ambiguous characters (0/O, 1/I) are excluded. 32 symbols ^ 10 = 50 bits of entropy.
|
||||
private const string Alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
|
||||
|
||||
public static string Generate() => RandomNumberGenerator.GetString(Alphabet, Length);
|
||||
|
||||
/// <summary>Accepts user input case-insensitively, ignoring whitespace and dashes.</summary>
|
||||
public static bool TryNormalize(string? input, [NotNullWhen(true)] out string? code)
|
||||
{
|
||||
code = null;
|
||||
if (string.IsNullOrWhiteSpace(input))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
Span<char> buffer = stackalloc char[Length];
|
||||
var count = 0;
|
||||
foreach (var c in input)
|
||||
{
|
||||
if (char.IsWhiteSpace(c) || c == '-')
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
var upper = char.ToUpperInvariant(c);
|
||||
if (count == Length || !Alphabet.Contains(upper))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
buffer[count++] = upper;
|
||||
}
|
||||
|
||||
if (count != Length)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
code = new string(buffer);
|
||||
return true;
|
||||
}
|
||||
|
||||
public static string Format(string code) =>
|
||||
code.Length == Length ? $"{code[..5]}-{code[5..]}" : code;
|
||||
}
|
||||
150
DataTransfer.Client/Shared/TransferProtocol.cs
Normal file
150
DataTransfer.Client/Shared/TransferProtocol.cs
Normal file
|
|
@ -0,0 +1,150 @@
|
|||
namespace DataTransfer.Client.Shared;
|
||||
|
||||
/// <summary>Constants shared by the relay server and the browser client.</summary>
|
||||
public static class TransferProtocol
|
||||
{
|
||||
public const string HubPath = "/hubs/transfer";
|
||||
|
||||
/// <summary>HTTP endpoint returning the current <see cref="ServerStatus" />.</summary>
|
||||
public const string StatusPath = "/api/status";
|
||||
|
||||
/// <summary>Plaintext size of one file chunk. Files are encrypted and relayed chunk by chunk.</summary>
|
||||
public const int FileChunkBytes = 256 * 1024;
|
||||
|
||||
/// <summary>Upper bound of a single encrypted frame (largest chunk plus framing and AES-GCM overhead).</summary>
|
||||
public const int MaxFrameBytes = FileChunkBytes + 1024;
|
||||
|
||||
/// <summary>
|
||||
/// SignalR limit for one incoming message: the largest frame base64 encoded inside JSON, plus room for the
|
||||
/// envelope. Kept tight because the server may buffer one such message per connected browser.
|
||||
/// </summary>
|
||||
public const long MaxHubMessageBytes = (MaxFrameBytes + 2) / 3 * 4 + 4 * 1024;
|
||||
|
||||
public const long MaxFileBytes = 100L * 1024 * 1024;
|
||||
|
||||
public const int MaxMessageLength = 10_000;
|
||||
|
||||
/// <summary>
|
||||
/// Maximum number of messages and files one side may send per connection. The receiver keeps all of them until
|
||||
/// the session is reset and closes the connection when the peer exceeds it.
|
||||
/// </summary>
|
||||
public const int MaxItemsPerConnection = 1_000;
|
||||
|
||||
/// <summary>Maximum total size of the files one side may send per connection; enforced like <see cref="MaxItemsPerConnection" />.</summary>
|
||||
public const long MaxFileBytesPerConnection = 1024L * 1024 * 1024;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Methods the browser invokes on the relay hub. Each client may invoke at most
|
||||
/// <c>Transfer:MaxInvocationsPerSecond</c> methods per second; further invocations are delayed.
|
||||
/// </summary>
|
||||
public interface ITransferHub
|
||||
{
|
||||
/// <summary>
|
||||
/// Returns a new proof-of-work challenge for <see cref="CreateConnection" />, or <c>null</c> if the server doesn't
|
||||
/// require one. It replaces any previous challenge of the connection.
|
||||
/// </summary>
|
||||
Task<BotCheckChallenge?> GetBotCheckChallenge();
|
||||
|
||||
/// <param name="botCheckSolution">The number that solves the latest challenge; any value if none is required.</param>
|
||||
Task<CreateConnectionResult> CreateConnection(int botCheckSolution);
|
||||
|
||||
Task<JoinConnectionResult> JoinConnection(string code);
|
||||
|
||||
/// <summary>
|
||||
/// Relays an opaque frame to the peer: first the plaintext key-exchange messages, then end-to-end encrypted
|
||||
/// frames.
|
||||
/// </summary>
|
||||
Task<SendStatus> Send(byte[] frame);
|
||||
|
||||
Task LeaveConnection();
|
||||
}
|
||||
|
||||
/// <summary>Methods the relay hub invokes on the browser.</summary>
|
||||
public interface ITransferHubClient
|
||||
{
|
||||
/// <summary>Someone joined the creator's connection; the key exchange follows via <see cref="Receive" />.</summary>
|
||||
Task PeerJoined();
|
||||
|
||||
Task Receive(byte[] frame);
|
||||
|
||||
Task ConnectionClosed(ConnectionClosedReason reason);
|
||||
|
||||
/// <summary>A queued create request got a free slot; the connection now exists.</summary>
|
||||
Task ConnectionCreated(CreateConnectionResult result);
|
||||
|
||||
/// <summary>The 1-based queue position of a waiting create request changed.</summary>
|
||||
Task QueuePositionChanged(int position);
|
||||
}
|
||||
|
||||
/// <param name="Code">The connection code, if <paramref name="Status" /> is <see cref="CreateStatus.Created" />.</param>
|
||||
/// <param name="JoinTimeout">The connection is closed unless someone joins within this period.</param>
|
||||
/// <param name="QueuePosition">
|
||||
/// 1-based position in the queue, if <paramref name="Status" /> is
|
||||
/// <see cref="CreateStatus.Queued" />.
|
||||
/// </param>
|
||||
public sealed record CreateConnectionResult(
|
||||
CreateStatus Status,
|
||||
string? Code,
|
||||
TimeSpan JoinTimeout,
|
||||
TimeSpan InactivityTimeout,
|
||||
int QueuePosition);
|
||||
|
||||
public enum CreateStatus
|
||||
{
|
||||
Created,
|
||||
|
||||
/// <summary>The connection limit is reached; the connection is created as soon as a slot becomes free.</summary>
|
||||
Queued,
|
||||
|
||||
/// <summary>The connection limit is reached and the queue is full.</summary>
|
||||
ServerBusy,
|
||||
|
||||
/// <summary>The network address of the browser already has the maximum number of connections or queued requests.</summary>
|
||||
TooManyConnections,
|
||||
|
||||
/// <summary>The proof-of-work solution was missing, wrong, reused or too late.</summary>
|
||||
BotCheckFailed
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Proof of work against creating connections in bulk: find the number between 0 and <paramref name="MaxNumber" />
|
||||
/// for which the lowercase hex SHA-256 of the UTF-8 string <c>Salt + number</c> equals <paramref name="Hash" />.
|
||||
/// </summary>
|
||||
public sealed record BotCheckChallenge(string Salt, string Hash, int MaxNumber);
|
||||
|
||||
/// <summary>Current load of the relay server.</summary>
|
||||
public sealed record ServerStatus(int ActiveConnections, int MaxConnections, int QueuedClients);
|
||||
|
||||
public sealed record JoinConnectionResult(JoinStatus Status, TimeSpan InactivityTimeout);
|
||||
|
||||
public enum JoinStatus
|
||||
{
|
||||
Joined,
|
||||
InvalidCode,
|
||||
NotFound,
|
||||
AlreadyInUse,
|
||||
|
||||
/// <summary>Too many browsers from the same network address are connected to the server.</summary>
|
||||
TooManyConnections
|
||||
}
|
||||
|
||||
public enum SendStatus
|
||||
{
|
||||
/// <summary>The frame was relayed to the peer.</summary>
|
||||
Delivered,
|
||||
WaitingForPeer,
|
||||
NotConnected,
|
||||
InvalidSize,
|
||||
|
||||
/// <summary>The connection relayed its maximum amount of data and was closed.</summary>
|
||||
TransferLimitReached
|
||||
}
|
||||
|
||||
public enum ConnectionClosedReason
|
||||
{
|
||||
PeerLeft,
|
||||
Inactivity,
|
||||
MaximumLifetime,
|
||||
TransferLimitReached
|
||||
}
|
||||
8
DataTransfer.Client/_Imports.razor
Normal file
8
DataTransfer.Client/_Imports.razor
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
@using Microsoft.AspNetCore.Components.Forms
|
||||
@using Microsoft.AspNetCore.Components.Routing
|
||||
@using Microsoft.AspNetCore.Components.Web
|
||||
@using static Microsoft.AspNetCore.Components.Web.RenderMode
|
||||
@using DataTransfer.Client
|
||||
@using DataTransfer.Client.Components
|
||||
@using DataTransfer.Client.Services
|
||||
@using DataTransfer.Client.Shared
|
||||
Loading…
Add table
Add a link
Reference in a new issue