DEV Community: Marcel Jurtz

Password-Synchronization with Syncthing

Marcel Jurtz — Thu, 25 Nov 2021 07:07:57 +0000

If you are reding this, chances are you already use a password manager. I have been doing that for several years now. But I have to admit that my password manager has only run on my phone so far and I have always transferred passwords that I use on my PC by hand. Probably out of sheer laziness. Today, I use this blog post to finally synchronise my password database between any number of devices - and to show you how to do it. The whole thing not only makes dealing with passwords more convenient, but naturally also reduces the inhibition threshold to actually use the applications. This in turn improves the overall security of your accounts.

Let’s briefly talk about the software: I use Keepass 2 on my PC and Keepass2Android on my mobile phone. This article should work with all applications that use kdbx files. To synchronise the individual files, I use Syncthing, which is available for various platforms. Accordingly, this article is not limited to Windows and Android.

Syncthing

Syncthing is an open source application that can be used to synchronise files between devices. The software supports synchronization via local and remote networks. As mentioned earlier, syncthing is available for a lot of different platforms, check out their download-page for details.

Syncthing is implemented in a peer-to-peer manner, which means that files are synchronised between the devices without a central server. Communication is protected via TLS and Perfect Forward Secrecy.

Syncthing allocated a unique ID to each device, which is used for address resolution, authentication and authorisation. In order for two devices to communicate with each other, they must know the respective device ID. If the IDs are known to each other, the devices are located using several discovery protocols:

Local Discovery: Broad- or multicast packets are sent into the local network via the router at intervals of 30 to 60 seconds. Each participating device therefore sends so-called announcement packets at regular intervals and keeps a table with all received announcements. Even in the event of an IP address change within a network, this ensures that the devices know the current IP address of all participants.
Global Discovery: If two devices are not in the same network, the global discovery protocol is used. This consists of two steps: First, each device periodically sends an announcement packet to a global discovery server. In the second step, each device sends a query packet with the (known) device ID of its counterpart. If the Syncthing server knows the device ID and the current location or IP address, it responds with the announcement packet.

Syncthing automatically starts the synchronization as soon as the location of the participating devices is known. If the devices cannot communicate directly with each other, e.g. due to firewall restrictions, a connection using a relay server is established. Syncthing hereby automatically detects whether a relay server is necessary or not. If you want to use syncthing only in your local network, you can also turn off the (remote) discovery protocols.

One last thing to mention is that syncthing doesn’t perform a real synchronization. It’s more of a push to other devices after recent changes.

Setup

To get started, use the download-page to get syncthing for your respective platform(s). I am going to use Android and Windows 10 for this post. For Windows, just unzip the downloaded folder and run the contained executable. You’ll be greeted with a web interface that shows you your installation details and let’s you the configure your setup.

After installing, you’ll want to connect your devices. To do so, I use my phone to scan the QR-Code on my PC. You can do this both ways, but might have to type in the id if you have no camera available. When you have the devices on the same local network, syncthing can discover devices automatically. On the second device, you will now receive a notification that the first device would like to establish a connection. As soon as you have agreed to this, you can continue with the configuration.

Synthing works with the concept of directories. A virtual directory is created for each physical folder I want to synchronize between devices. The virtual folders are displayed in the web interface. I start by creating a “Keepass” folder on my Android device and link it to the file path I want to use. I then select my PC to share the folder with it. After saving, I receive a new notification on my PC to include the shared folder. I confirm this too and now configure the physical part of my second device.

Now the two directories are linked, and as long as both devices are online, Syncthing will keep their contents up to date. It also displays the current status, which is currently “Out of sync”. Shortly afterwards, syncthing starts the first adjustment and my Keepass file already ends up on the PC.

Conclusion

Syncthing is a fast, simple and very flexible solution to synchronise files between multiple devices. This also works very well with Keepass databases, but care must be taken here regarding merge conflicts. You should therefore avoid changing data on both databases while both devices are not connected. If necessary, Keepass itself has a merge function that can be used to synchronise database statuses that have drifted apart.

Resolve Open Generics with ASP.NET Cores DI-Container

Marcel Jurtz — Tue, 10 Nov 2020 20:08:33 +0000

ASP .NET Core already has quite a decent di-container built in. However, there are some quirks you might need to be aware of. In one of my applications, I've been using a factory pattern to register my views by using open generics. To be more clear about that: I have an Interface IView<TView>, and I want to register all of this interfaces implementations.

As I found out, Microsofts DI-Container currently doesn't support that by default (text me if I'm wrong!), but there's a solution for this problem.
Scrutor is a package that adds more complex di-features - specifically scanning. This means that, using this library, you now have the ability to scan through your assemblies and perform registrations based on your findings.

Now, for my case, this was quite simple: All I had to do was to add the following snippet to my startup-class:

services.Scan(scan =>
  scan.FromAssembliesOf(typeof(IView<>))
    .AddClasses(classes =>
    classes.AssignableTo(typeof(IView<>)).Where(x => !x.IsGenericType))
        .AsImplementedInterfaces()
        .WithTransientLifetime());

And that's it! Now, all the implementations of the interface find their way into my di container and I can easily retrieve new instances by utilizing the following factory class:

public class ViewFactory : IViewFactory
{
    private readonly IServiceProvider _services;
    public ViewFactory(IServiceProvider services)
    {
        _services = services;
    }

    public Task<TView> CreateViewAsync<TView>()
    {
        var builder = _services.GetService<IView<TView>>();

        if (builder == null) 
        {
          throw new Exception($"View {typeof(TView)} not registered");
        }

        return builder.BuildAsync();
    }
}

If needed, you could easily extend this by a second type parameter to specify e.g. arguments to pass to the view. Those would then be passed to the CreateViewAsync-Method, which in turn would forward them to the builders BuildAsync-Method.

Redirection with .htaccess and PHP

Marcel Jurtz — Sat, 07 Nov 2020 09:58:03 +0000

I’ve been starting a new blog on my domain, for which I wanted to use the blog subdomain. However, this subdomain was already in use for all my coding-related stuff. So, I decided to move my current blog from /blog to /coding and upload my new blog to /blog. So far, so good. Now I have both of my blogs up and running.

There’s just one problem: Any incoming traffic to existing posts on my blog would resolve to 404s. In todays post, I’m gonna show you how I resolved that issue.

First of all, my domain runs on an apache server, so I decided to capture all 404s and redirect them to a specific errorpage. To do this, I needed to add the following statement to my .htaccess file, which is located in the root directory of my webspace.

ErrorDocument 404 /notfound.php

Note that it’s important to use a relative path to the php file. If you use an absolute path, you will override the query-string variable in php, which you might need later for the redirect.

I added the notfound.php file to my blog-directory, from where it will be resolved correctly. The file looks like this:

<?php 
  header("Location: https://coding.mjurtz.com" . $_SERVER["REQUEST_URI"], true, 301); 
  die(); 
?>

All it does is it takes the request uri, and appends it to the new domain, passing a 301 — permanent redirect back to the browser. And that’s it already — My old links are still working and I can work on both blogs separately.

FluentValidation in ASP.NET Core

Marcel Jurtz — Tue, 06 Oct 2020 08:03:18 +0000

Have you been implementing the validation of your ViewModels in ASP.NET (Core) using DataAttributes so far? If so, chances are you've always been dissatisfied because your classes became messy and full of unnecessarily replicated code. Yes? Then today's post is for you.

FluentValidation

FluentValidation is a way to define strongly typed validation for classes in the form of a Fluent API. The term fluent in this case refers to a code structure where a function always return the modified object. This way, you can chain together multiple method calls and produce very readable source code, especially in configurations where it is often used. You may already be familiar with this structure from areas like the ASP.NET setup or LINQ.

FluentValidation is a popular library for defining validation rules in .NET and is available open source at GitHub. Oh, and before I jump into the topic: the projects documentation is very good and should be more than sufficient for most of your questions.

Installation & Setup

To use FluentValidation, you first need to install corresponding NuGet package FluentValidation.AspNetCore. After that, the only thing left to do is the configuration in your applications startup class. Just add a call to AddFluentValidation in the method ConfigureServices and you're all set! To work correctly with the DI infrastructure, the validators must be defined here afterwards tough:

public void ConfigureServices(IServiceCollection services) {
    services.AddMvc()
        // ...
        .AddFluentValidation();

    services.AddTransient<IValidator<ClubMember>, ClubMemberValidator>();
    // ...
}

As you may guess, that would of course get very messy very quickly, so let's check for another way to achieve that. Fortunately, the authors also thought of that and provided another solution: the automatic registration of all validators inside a given assembly. The only two requirements to these is that they are a) marked as public and b) inherit the generic AbstractValidator-class.

To do that, you just need to customize the call to AddFluentValidation as follows:

.AddFluentValidation(fv => fv.RegisterValidatorsFromAssemblyContaining<Startup>());

This will now register all validators, that are contained inside the same assembly as Startup. Knowing that, we can just jump straight into defining our first validator. In my case, that's the one for the ClubMember-class, which could look like this:

public class ClubMember {
    public int Id { get; set; }
    public int MemberId { get; set; }
    public int ClubId { get; set; }
    public string Role { get; set; }
    public int Number { get; set; }
}

public class ClubMemberValidator : AbstractValidator<ClubMember> {
    public ClubMemberValidator() {
        (x => x.Role).Length(3, 25);
        RuleFor(x => x.Number).InclusiveBetween(1, 100);
        // ...
    }
}

There are multiple predefined validationrules available in FluentValidation. However, you can of course create your own if you need to support a specific usecase. The validation itself is now set up, and you can check it by calling ModelState.IsValid inside your controller actions.

Pitfalls

There are a few things to be considered when using the library. For example, the regular asp.net validation using DataAttributes is still active and will be applied after the fluentvalidation. It may be helpful to clean up old code to avoid unexpected side effects.

Another point to keep in mind is that complex objects are not automatically checked further down in their hierarchical structure. If you want to your validator to validate child objects by default, you have to specify this either on the object itself or in the configuration. To achieve this, you can use the property ImplicitlyValidateChildProperties.

FluentValidation itself is meant to be used for server-side validation. However, it can also be used to provide metadata for validation on the client side. You can find more information on this topic in the project documentation linked above.

TL;DR

In my opinion, FluentValidation offers a very nice way to define strongly typed validation rules in ASP.NET (Core), without having to mess up your classes. However, there are many more details I haven't covered yet. As I mentioned earlier, the documentation of the project is a very good place to get answers to potential questions and general information, but you also might find posts on various details here in the future.

How do you organize your personal projects

Marcel Jurtz — Fri, 18 Sep 2020 11:01:14 +0000

What software do you guys use to manage your personal projects? Especially for requirements and feature documentation, but also things like time management and so on.