diff --git a/LANCommander/Controllers/KeysController.cs b/LANCommander/Controllers/KeysController.cs
new file mode 100644
index 0000000..c2013bf
--- /dev/null
+++ b/LANCommander/Controllers/KeysController.cs
@@ -0,0 +1,125 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Rendering;
+using Microsoft.EntityFrameworkCore;
+using LANCommander.Data;
+using LANCommander.Data.Models;
+using Microsoft.AspNetCore.Authorization;
+using LANCommander.Models;
+
+namespace LANCommander.Controllers
+{
+    [Authorize(Roles = "Administrator")]
+    public class KeysController : Controller
+    {
+        private readonly DatabaseContext Context;
+
+        public KeysController(DatabaseContext context)
+        {
+            Context = context;
+        }
+
+        public async Task<IActionResult> Details(Guid? id)
+        {
+            using (var repo = new Repository<Game>(Context, HttpContext))
+            {
+                var game = await repo.Find(id.GetValueOrDefault());
+
+                if (game == null)
+                    return NotFound();
+
+                return View(game);
+            }
+        }
+
+        public async Task<IActionResult> Edit(Guid? id)
+        {
+            using (var repo = new Repository<Game>(Context, HttpContext))
+            {
+                var game = await repo.Find(id.GetValueOrDefault());
+
+                if (game == null)
+                    return NotFound();
+
+                var viewModel = new EditKeysViewModel()
+                {
+                    Game = game,
+                    Keys = String.Join("\n", game.Keys.OrderByDescending(k => k.ClaimedOn).Select(k => k.Value))
+                };
+
+                return View(viewModel);
+            }
+        }
+
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Edit(Guid id, EditKeysViewModel viewModel)
+        {
+            var keys = viewModel.Keys.Split("\n").Select(k => k.Trim()).Where(k => !String.IsNullOrWhiteSpace(k));
+
+            using (var gameRepo = new Repository<Game>(Context, HttpContext))
+            {
+                var game = await gameRepo.Find(id);
+
+                if (game == null)
+                    return NotFound();
+
+                using (var keyRepo = new Repository<Key>(Context, HttpContext))
+                {
+                    var existingKeys = keyRepo.Get(k => k.Game.Id == id).ToList();
+
+                    var keysDeleted = existingKeys.Where(k => !keys.Contains(k.Value));
+                    var keysAdded = keys.Where(k => !existingKeys.Any(e => e.Value == k));
+
+                    foreach (var key in keysDeleted)
+                        keyRepo.Delete(key);
+
+                    foreach (var key in keysAdded)
+                        await keyRepo.Add(new Key()
+                        {
+                            Game = game,
+                            Value = key,
+                        });
+
+                    await keyRepo.SaveChanges();
+                }
+            }
+
+            return RedirectToAction("Edit", "Games", new { id = id });
+        }
+
+        public async Task<IActionResult> Release(Guid id)
+        {
+            using (var repo = new Repository<Key>(Context, HttpContext))
+            {
+                var key = await repo.Find(id);
+
+                if (key == null)
+                    return NotFound();
+
+                switch (key.AllocationMethod)
+                {
+                    case KeyAllocationMethod.UserAccount:
+                        key.ClaimedByUser = null;
+                        key.ClaimedOn = null;
+                        break;
+
+                    case KeyAllocationMethod.MacAddress:
+                        key.ClaimedByMacAddress = "";
+                        key.ClaimedOn = null;
+                        break;
+                }
+
+                repo.Update(key);
+
+                await repo.SaveChanges();
+
+                return RedirectToAction("Details", "Keys", new { id = key.Game.Id });
+            }
+        }
+    }
+}
diff --git a/LANCommander/Data/DatabaseContext.cs b/LANCommander/Data/DatabaseContext.cs
index 9475be6..19f9f5b 100644
--- a/LANCommander/Data/DatabaseContext.cs
+++ b/LANCommander/Data/DatabaseContext.cs
@@ -30,6 +30,11 @@ namespace LANCommander.Data
                 .HasMany(g => g.Archives)
                 .WithOne(g => g.Game)
                 .IsRequired(false);
+
+            builder.Entity<Game>()
+                .HasMany(g => g.Keys)
+                .WithOne(g => g.Game)
+                .IsRequired(false);
         }
 
         public DbSet<Game>? Games { get; set; }
@@ -37,5 +42,7 @@ namespace LANCommander.Data
         public DbSet<Tag>? Tags { get; set; }
 
         public DbSet<Company>? Companies { get; set; }
+
+        public DbSet<Key>? Keys { get; set; }
     }
 }
\ No newline at end of file
diff --git a/LANCommander/Data/Models/Game.cs b/LANCommander/Data/Models/Game.cs
index e26ae6b..d045a67 100644
--- a/LANCommander/Data/Models/Game.cs
+++ b/LANCommander/Data/Models/Game.cs
@@ -21,5 +21,8 @@ namespace LANCommander.Data.Models
         public virtual Company? Developer { get; set; }
 
         public virtual ICollection<Archive>? Archives { get; set; }
+
+        public string? ValidKeyRegex { get; set; }
+        public virtual ICollection<Key>? Keys { get; set; }
     }
 }
diff --git a/LANCommander/Data/Models/Key.cs b/LANCommander/Data/Models/Key.cs
new file mode 100644
index 0000000..f898e0c
--- /dev/null
+++ b/LANCommander/Data/Models/Key.cs
@@ -0,0 +1,28 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace LANCommander.Data.Models
+{
+    [Table("Keys")]
+    public class Key : BaseModel
+    {
+        [MaxLength(255)]
+        public string Value { get; set; }
+        public virtual Game Game { get; set; }
+        public KeyAllocationMethod AllocationMethod { get; set; }
+        [MaxLength(17)]
+        public string? ClaimedByMacAddress { get; set; }
+        [MaxLength(15)]
+        public string? ClaimedByIpv4Address { get; set; }
+        [MaxLength(255)]
+        public string? ClaimedByComputerName { get; set; }
+        public virtual User? ClaimedByUser { get; set; }
+        public DateTime? ClaimedOn { get; set; }
+    }
+
+    public enum KeyAllocationMethod
+    {
+        UserAccount,
+        MacAddress
+    }
+}
diff --git a/LANCommander/Migrations/20230108011351_AddKeyModel.Designer.cs b/LANCommander/Migrations/20230108011351_AddKeyModel.Designer.cs
new file mode 100644
index 0000000..cf30283
--- /dev/null
+++ b/LANCommander/Migrations/20230108011351_AddKeyModel.Designer.cs
@@ -0,0 +1,665 @@
+// <auto-generated />
+using System;
+using LANCommander.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace LANCommander.Migrations
+{
+    [DbContext(typeof(DatabaseContext))]
+    [Migration("20230108011351_AddKeyModel")]
+    partial class AddKeyModel
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "6.0.8");
+
+            modelBuilder.Entity("GameTag", b =>
+                {
+                    b.Property<Guid>("GamesId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("TagsId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("GamesId", "TagsId");
+
+                    b.HasIndex("TagsId");
+
+                    b.ToTable("GameTag");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Archive", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Changelog")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("CompressedSize")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("LastVersionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ObjectKey")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("UncompressedSize")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("UpdatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Version")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("GameId");
+
+                    b.HasIndex("LastVersionId");
+
+                    b.HasIndex("UpdatedById");
+
+                    b.ToTable("Archive");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Company", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("UpdatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("UpdatedById");
+
+                    b.ToTable("Companies");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Game", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("DeveloperId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DirectoryName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("PublisherId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("ReleasedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("UpdatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ValidKeyRegex")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("DeveloperId");
+
+                    b.HasIndex("PublisherId");
+
+                    b.HasIndex("UpdatedById");
+
+                    b.ToTable("Games");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Key", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AllocationMethod")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimedByComputerName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimedByIpv4Address")
+                        .HasMaxLength(15)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimedByMacAddress")
+                        .HasMaxLength(17)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("ClaimedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ClaimedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("UpdatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClaimedByUserId");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("GameId");
+
+                    b.HasIndex("UpdatedById");
+
+                    b.ToTable("Keys");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Role", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Tag", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("UpdatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("UpdatedById");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("RefreshToken")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("RefreshTokenExpiration")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderKey")
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LoginProvider")
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("GameTag", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.Game", null)
+                        .WithMany()
+                        .HasForeignKey("GamesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("LANCommander.Data.Models.Tag", null)
+                        .WithMany()
+                        .HasForeignKey("TagsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Archive", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedById");
+
+                    b.HasOne("LANCommander.Data.Models.Game", "Game")
+                        .WithMany("Archives")
+                        .HasForeignKey("GameId");
+
+                    b.HasOne("LANCommander.Data.Models.Archive", "LastVersion")
+                        .WithMany()
+                        .HasForeignKey("LastVersionId");
+
+                    b.HasOne("LANCommander.Data.Models.User", "UpdatedBy")
+                        .WithMany()
+                        .HasForeignKey("UpdatedById");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("Game");
+
+                    b.Navigation("LastVersion");
+
+                    b.Navigation("UpdatedBy");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Company", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedById");
+
+                    b.HasOne("LANCommander.Data.Models.User", "UpdatedBy")
+                        .WithMany()
+                        .HasForeignKey("UpdatedById");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("UpdatedBy");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Game", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedById");
+
+                    b.HasOne("LANCommander.Data.Models.Company", "Developer")
+                        .WithMany("DevelopedGames")
+                        .HasForeignKey("DeveloperId");
+
+                    b.HasOne("LANCommander.Data.Models.Company", "Publisher")
+                        .WithMany("PublishedGames")
+                        .HasForeignKey("PublisherId");
+
+                    b.HasOne("LANCommander.Data.Models.User", "UpdatedBy")
+                        .WithMany()
+                        .HasForeignKey("UpdatedById");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("Developer");
+
+                    b.Navigation("Publisher");
+
+                    b.Navigation("UpdatedBy");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Key", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", "ClaimedByUser")
+                        .WithMany()
+                        .HasForeignKey("ClaimedByUserId");
+
+                    b.HasOne("LANCommander.Data.Models.User", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedById");
+
+                    b.HasOne("LANCommander.Data.Models.Game", "Game")
+                        .WithMany("Keys")
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("LANCommander.Data.Models.User", "UpdatedBy")
+                        .WithMany()
+                        .HasForeignKey("UpdatedById");
+
+                    b.Navigation("ClaimedByUser");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("Game");
+
+                    b.Navigation("UpdatedBy");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Tag", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedById");
+
+                    b.HasOne("LANCommander.Data.Models.User", "UpdatedBy")
+                        .WithMany()
+                        .HasForeignKey("UpdatedById");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("UpdatedBy");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("LANCommander.Data.Models.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Company", b =>
+                {
+                    b.Navigation("DevelopedGames");
+
+                    b.Navigation("PublishedGames");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Game", b =>
+                {
+                    b.Navigation("Archives");
+
+                    b.Navigation("Keys");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/LANCommander/Migrations/20230108011351_AddKeyModel.cs b/LANCommander/Migrations/20230108011351_AddKeyModel.cs
new file mode 100644
index 0000000..e900830
--- /dev/null
+++ b/LANCommander/Migrations/20230108011351_AddKeyModel.cs
@@ -0,0 +1,93 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LANCommander.Migrations
+{
+    public partial class AddKeyModel : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "ValidKeyRegex",
+                table: "Games",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "Keys",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "TEXT", nullable: false),
+                    Value = table.Column<string>(type: "TEXT", nullable: false),
+                    GameId = table.Column<Guid>(type: "TEXT", nullable: false),
+                    AllocationMethod = table.Column<int>(type: "INTEGER", nullable: false),
+                    ClaimedByMacAddress = table.Column<string>(type: "TEXT", maxLength: 17, nullable: true),
+                    ClaimedByIpv4Address = table.Column<string>(type: "TEXT", maxLength: 15, nullable: true),
+                    ClaimedByComputerName = table.Column<string>(type: "TEXT", maxLength: 256, nullable: true),
+                    ClaimedByUserId = table.Column<Guid>(type: "TEXT", nullable: true),
+                    ClaimedOn = table.Column<DateTime>(type: "TEXT", nullable: true),
+                    CreatedOn = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    CreatedById = table.Column<Guid>(type: "TEXT", nullable: true),
+                    UpdatedOn = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    UpdatedById = table.Column<Guid>(type: "TEXT", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Keys", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Keys_AspNetUsers_ClaimedByUserId",
+                        column: x => x.ClaimedByUserId,
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_Keys_AspNetUsers_CreatedById",
+                        column: x => x.CreatedById,
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_Keys_AspNetUsers_UpdatedById",
+                        column: x => x.UpdatedById,
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_Keys_Games_GameId",
+                        column: x => x.GameId,
+                        principalTable: "Games",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Keys_ClaimedByUserId",
+                table: "Keys",
+                column: "ClaimedByUserId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Keys_CreatedById",
+                table: "Keys",
+                column: "CreatedById");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Keys_GameId",
+                table: "Keys",
+                column: "GameId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Keys_UpdatedById",
+                table: "Keys",
+                column: "UpdatedById");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Keys");
+
+            migrationBuilder.DropColumn(
+                name: "ValidKeyRegex",
+                table: "Games");
+        }
+    }
+}
diff --git a/LANCommander/Migrations/20230108014549_AdjustKeyColumnLengths.Designer.cs b/LANCommander/Migrations/20230108014549_AdjustKeyColumnLengths.Designer.cs
new file mode 100644
index 0000000..d84c802
--- /dev/null
+++ b/LANCommander/Migrations/20230108014549_AdjustKeyColumnLengths.Designer.cs
@@ -0,0 +1,664 @@
+// <auto-generated />
+using System;
+using LANCommander.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace LANCommander.Migrations
+{
+    [DbContext(typeof(DatabaseContext))]
+    [Migration("20230108014549_AdjustKeyColumnLengths")]
+    partial class AdjustKeyColumnLengths
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "6.0.8");
+
+            modelBuilder.Entity("GameTag", b =>
+                {
+                    b.Property<Guid>("GamesId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("TagsId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("GamesId", "TagsId");
+
+                    b.HasIndex("TagsId");
+
+                    b.ToTable("GameTag");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Archive", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Changelog")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("CompressedSize")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("LastVersionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ObjectKey")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("UncompressedSize")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("UpdatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Version")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("GameId");
+
+                    b.HasIndex("LastVersionId");
+
+                    b.HasIndex("UpdatedById");
+
+                    b.ToTable("Archive");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Company", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("UpdatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("UpdatedById");
+
+                    b.ToTable("Companies");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Game", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("DeveloperId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DirectoryName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("PublisherId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("ReleasedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("UpdatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ValidKeyRegex")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("DeveloperId");
+
+                    b.HasIndex("PublisherId");
+
+                    b.HasIndex("UpdatedById");
+
+                    b.ToTable("Games");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Key", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AllocationMethod")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimedByComputerName")
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimedByIpv4Address")
+                        .HasMaxLength(15)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimedByMacAddress")
+                        .HasMaxLength(17)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("ClaimedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ClaimedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("UpdatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClaimedByUserId");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("GameId");
+
+                    b.HasIndex("UpdatedById");
+
+                    b.ToTable("Keys");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Role", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Tag", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("UpdatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("UpdatedById");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("RefreshToken")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("RefreshTokenExpiration")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderKey")
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LoginProvider")
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("GameTag", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.Game", null)
+                        .WithMany()
+                        .HasForeignKey("GamesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("LANCommander.Data.Models.Tag", null)
+                        .WithMany()
+                        .HasForeignKey("TagsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Archive", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedById");
+
+                    b.HasOne("LANCommander.Data.Models.Game", "Game")
+                        .WithMany("Archives")
+                        .HasForeignKey("GameId");
+
+                    b.HasOne("LANCommander.Data.Models.Archive", "LastVersion")
+                        .WithMany()
+                        .HasForeignKey("LastVersionId");
+
+                    b.HasOne("LANCommander.Data.Models.User", "UpdatedBy")
+                        .WithMany()
+                        .HasForeignKey("UpdatedById");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("Game");
+
+                    b.Navigation("LastVersion");
+
+                    b.Navigation("UpdatedBy");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Company", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedById");
+
+                    b.HasOne("LANCommander.Data.Models.User", "UpdatedBy")
+                        .WithMany()
+                        .HasForeignKey("UpdatedById");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("UpdatedBy");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Game", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedById");
+
+                    b.HasOne("LANCommander.Data.Models.Company", "Developer")
+                        .WithMany("DevelopedGames")
+                        .HasForeignKey("DeveloperId");
+
+                    b.HasOne("LANCommander.Data.Models.Company", "Publisher")
+                        .WithMany("PublishedGames")
+                        .HasForeignKey("PublisherId");
+
+                    b.HasOne("LANCommander.Data.Models.User", "UpdatedBy")
+                        .WithMany()
+                        .HasForeignKey("UpdatedById");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("Developer");
+
+                    b.Navigation("Publisher");
+
+                    b.Navigation("UpdatedBy");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Key", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", "ClaimedByUser")
+                        .WithMany()
+                        .HasForeignKey("ClaimedByUserId");
+
+                    b.HasOne("LANCommander.Data.Models.User", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedById");
+
+                    b.HasOne("LANCommander.Data.Models.Game", "Game")
+                        .WithMany("Keys")
+                        .HasForeignKey("GameId");
+
+                    b.HasOne("LANCommander.Data.Models.User", "UpdatedBy")
+                        .WithMany()
+                        .HasForeignKey("UpdatedById");
+
+                    b.Navigation("ClaimedByUser");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("Game");
+
+                    b.Navigation("UpdatedBy");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Tag", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedById");
+
+                    b.HasOne("LANCommander.Data.Models.User", "UpdatedBy")
+                        .WithMany()
+                        .HasForeignKey("UpdatedById");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("UpdatedBy");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("LANCommander.Data.Models.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Company", b =>
+                {
+                    b.Navigation("DevelopedGames");
+
+                    b.Navigation("PublishedGames");
+                });
+
+            modelBuilder.Entity("LANCommander.Data.Models.Game", b =>
+                {
+                    b.Navigation("Archives");
+
+                    b.Navigation("Keys");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/LANCommander/Migrations/20230108014549_AdjustKeyColumnLengths.cs b/LANCommander/Migrations/20230108014549_AdjustKeyColumnLengths.cs
new file mode 100644
index 0000000..38bd522
--- /dev/null
+++ b/LANCommander/Migrations/20230108014549_AdjustKeyColumnLengths.cs
@@ -0,0 +1,38 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LANCommander.Migrations
+{
+    public partial class AdjustKeyColumnLengths : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Keys_Games_GameId",
+                table: "Keys");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Keys_Games_GameId",
+                table: "Keys",
+                column: "GameId",
+                principalTable: "Games",
+                principalColumn: "Id");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Keys_Games_GameId",
+                table: "Keys");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Keys_Games_GameId",
+                table: "Keys",
+                column: "GameId",
+                principalTable: "Games",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}
diff --git a/LANCommander/Migrations/DatabaseContextModelSnapshot.cs b/LANCommander/Migrations/DatabaseContextModelSnapshot.cs
index eb4e7d1..ae0e643 100644
--- a/LANCommander/Migrations/DatabaseContextModelSnapshot.cs
+++ b/LANCommander/Migrations/DatabaseContextModelSnapshot.cs
@@ -158,6 +158,9 @@ namespace LANCommander.Migrations
                     b.Property<DateTime>("UpdatedOn")
                         .HasColumnType("TEXT");
 
+                    b.Property<string>("ValidKeyRegex")
+                        .HasColumnType("TEXT");
+
                     b.HasKey("Id");
 
                     b.HasIndex("CreatedById");
@@ -171,6 +174,66 @@ namespace LANCommander.Migrations
                     b.ToTable("Games");
                 });
 
+            modelBuilder.Entity("LANCommander.Data.Models.Key", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AllocationMethod")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimedByComputerName")
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimedByIpv4Address")
+                        .HasMaxLength(15)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimedByMacAddress")
+                        .HasMaxLength(17)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("ClaimedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ClaimedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("UpdatedById")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClaimedByUserId");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("GameId");
+
+                    b.HasIndex("UpdatedById");
+
+                    b.ToTable("Keys");
+                });
+
             modelBuilder.Entity("LANCommander.Data.Models.Role", b =>
                 {
                     b.Property<Guid>("Id")
@@ -487,6 +550,33 @@ namespace LANCommander.Migrations
                     b.Navigation("UpdatedBy");
                 });
 
+            modelBuilder.Entity("LANCommander.Data.Models.Key", b =>
+                {
+                    b.HasOne("LANCommander.Data.Models.User", "ClaimedByUser")
+                        .WithMany()
+                        .HasForeignKey("ClaimedByUserId");
+
+                    b.HasOne("LANCommander.Data.Models.User", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedById");
+
+                    b.HasOne("LANCommander.Data.Models.Game", "Game")
+                        .WithMany("Keys")
+                        .HasForeignKey("GameId");
+
+                    b.HasOne("LANCommander.Data.Models.User", "UpdatedBy")
+                        .WithMany()
+                        .HasForeignKey("UpdatedById");
+
+                    b.Navigation("ClaimedByUser");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("Game");
+
+                    b.Navigation("UpdatedBy");
+                });
+
             modelBuilder.Entity("LANCommander.Data.Models.Tag", b =>
                 {
                     b.HasOne("LANCommander.Data.Models.User", "CreatedBy")
@@ -563,6 +653,8 @@ namespace LANCommander.Migrations
             modelBuilder.Entity("LANCommander.Data.Models.Game", b =>
                 {
                     b.Navigation("Archives");
+
+                    b.Navigation("Keys");
                 });
 #pragma warning restore 612, 618
         }
diff --git a/LANCommander/Models/EditKeysViewModel.cs b/LANCommander/Models/EditKeysViewModel.cs
new file mode 100644
index 0000000..fc53512
--- /dev/null
+++ b/LANCommander/Models/EditKeysViewModel.cs
@@ -0,0 +1,10 @@
+using LANCommander.Data.Models;
+
+namespace LANCommander.Models
+{
+    public class EditKeysViewModel
+    {
+        public Game Game { get; set; }
+        public string Keys { get; set; }
+    }
+}
diff --git a/LANCommander/Views/Games/Edit.cshtml b/LANCommander/Views/Games/Edit.cshtml
index c8c8596..20e08cc 100644
--- a/LANCommander/Views/Games/Edit.cshtml
+++ b/LANCommander/Views/Games/Edit.cshtml
@@ -1,4 +1,5 @@
-@model LANCommander.Data.Models.Game
+@using LANCommander.Data.Models
+@model LANCommander.Data.Models.Game
 
 @{
     ViewData["Title"] = "Edit";
@@ -62,6 +63,61 @@
                 </form>
             </div>
 
+            <div class="col-12">
+                <div class="card">
+                    @if (Model.Keys != null && Model.Keys.Count > 0)
+                    {
+                        <div class="card-header">
+                            <h3 class="card-title">Keys</h3>
+                            <div class="card-actions">
+                                <a asp-action="Details" asp-controller="Keys" asp-route-id="@Model.Id" class="btn btn-ghost-primary">
+                                    Details
+                                </a>
+                            </div>
+                        </div>
+
+                        var keysAvailable = Model.Keys.Count(k =>
+                        {
+                            return (k.AllocationMethod == KeyAllocationMethod.MacAddress && String.IsNullOrWhiteSpace(k.ClaimedByMacAddress)) ||
+                                (k.AllocationMethod == KeyAllocationMethod.UserAccount && k.ClaimedByUser == null);
+                        });
+
+                        <div class="card-body">
+                            <div class="datagrid text-center">
+                                <div class="datagrid-item">
+                                    <div class="datagrid-title">Available</div>
+                                    <div class="datagrid-content">
+                                        @keysAvailable
+                                    </div>
+                                </div>
+                                <div class="datagrid-item">
+                                    <div class="datagrid-title">Claimed</div>
+                                    <div class="datagrid-content">
+                                        @(Model.Keys.Count - keysAvailable)
+                                    </div>
+                                </div>
+                                <div class="datagrid-item">
+                                    <div class="datagrid-title">Total</div>
+                                    <div class="datagrid-content">
+                                        @Model.Keys.Count
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    }
+                    else
+                    {
+                        <div class="empty">
+                            <p class="empty-title">No Keys</p>
+                            <p class="empty-subtitle text-muted">There have been no keys added for this game.</p>
+                            <div class="empty-action">
+                                <a asp-action="Edit" asp-controller="Keys" asp-route-id="@Model.Id" class="btn btn-primary">Edit Keys</a>
+                            </div>
+                        </div>
+                    }
+                </div>
+            </div>
+
             <div class="col-12">
                 <div class="card">
                     @if (Model.Archives != null && Model.Archives.Count > 0)
diff --git a/LANCommander/Views/Keys/Details.cshtml b/LANCommander/Views/Keys/Details.cshtml
new file mode 100644
index 0000000..936d504
--- /dev/null
+++ b/LANCommander/Views/Keys/Details.cshtml
@@ -0,0 +1,106 @@
+@using LANCommander.Data.Models
+@model LANCommander.Data.Models.Game
+
+@{
+    ViewData["Title"] = "Keys | " + Model.Title;
+}
+
+<div class="container-xl">
+    <!-- Page title -->
+    <div class="page-header d-print-none">
+        <div class="row align-items-center">
+            <div class="col">
+                <div class="page-pretitle">@Model.Title</div>
+                <h2 class="page-title">
+                    Keys
+                </h2>
+            </div>
+
+            <div class="col-auto ms-auto">
+                <div class="btn-list">
+                    <a asp-action="Edit" asp-controller="Games" asp-route-id="@Model.Id" class="btn btn-ghost-primary">Back</a>
+                    <a asp-action="Edit" asp-route-id="@Model.Id" class="btn btn-primary d-none d-sm-inline-block">Edit</a>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<div class="page-body">
+    <div class="container-xl">
+        <div class="row row-cards">
+            <div class="col-12">
+                <form asp-action="Edit" class="card">
+                    @if (Model.Keys != null && Model.Keys.Count > 0)
+                    {
+                        <div class="table-responsive">
+                            <table class="table table-vcenter table-mobile-md card-table">
+                                <thead>
+                                    <tr>
+                                        <th>Key</th>
+                                        <th>Allocation Method</th>
+                                        <th>Claimed By</th>
+                                        <th>Claimed On</th>
+                                        <th></th>
+                                    </tr>
+                                </thead>
+
+                                <tbody>
+                                    @foreach (var key in Model.Keys.OrderByDescending(k => k.ClaimedOn))
+                                    {
+                                        <tr>
+                                            <td class="game-key">@Html.DisplayFor(m => key.Value)</td>
+                                            <td>@Html.DisplayFor(m => key.AllocationMethod)</td>
+                                            <td>
+                                                @switch (key.AllocationMethod)
+                                                {
+                                                    case KeyAllocationMethod.MacAddress:
+                                                        <text>@key.ClaimedByMacAddress</text>
+                                                        break;
+
+                                                    case KeyAllocationMethod.UserAccount:
+                                                        <text>@key.ClaimedByUser?.UserName</text>
+                                                        break;
+                                                }
+                                            </td>
+                                            <td>@key.ClaimedOn</td>
+                                            <td>
+                                                <div class="btn-list flex-nowrap justify-content-end">
+                                                    @if ((key.AllocationMethod == KeyAllocationMethod.MacAddress && !String.IsNullOrWhiteSpace(key.ClaimedByMacAddress)) || (key.AllocationMethod == KeyAllocationMethod.UserAccount && key.ClaimedByUser != null))
+                                                    {
+                                                        <a asp-action="Release" asp-controller="Keys" asp-route-id="@key.Id" class="btn btn-sm btn-ghost-dark">Release</a>   
+                                                    }
+                                                    <a asp-action="Delete" asp-controller="Keys" asp-route-id="@key.Id" class="btn btn-sm btn-ghost-danger">Delete</a>
+                                                </div>
+                                            </td>
+                                        </tr>
+                                    }
+                                </tbody>
+                            </table>
+                        </div>
+                    }
+                    else
+                    {
+                        <div class="empty">
+                            <p class="empty-title">No Key</p>
+                            <p class="empty-subtitle text-muted">There have been no keys added for this game.</p>
+                            <div class="empty-action">
+                                <a asp-action="Edit" asp-controller="Keys" asp-route-id="@Model.Id" class="btn btn-primary">Edit Keys</a>
+                            </div>
+                        </div>
+                    }
+                </form>
+            </div>
+        </div>
+    </div>
+</div>
+
+<style>
+    .game-key {
+        font-family: var(--tblr-font-monospace);
+    }
+</style>
+
+@section Scripts {
+    @{ await Html.RenderPartialAsync("_ValidationScriptsPartial"); }
+}
diff --git a/LANCommander/Views/Keys/Edit.cshtml b/LANCommander/Views/Keys/Edit.cshtml
new file mode 100644
index 0000000..86f0101
--- /dev/null
+++ b/LANCommander/Views/Keys/Edit.cshtml
@@ -0,0 +1,100 @@
+@model LANCommander.Models.EditKeysViewModel
+
+@{
+    ViewData["Title"] = "Edit Keys | " + Model.Game.Title;
+}
+
+<div class="container-xl">
+    <!-- Page title -->
+    <div class="page-header d-print-none">
+        <div class="row align-items-center">
+            <div class="col">
+                <div class="page-pretitle">@Model.Game.Title</div>
+                <h2 class="page-title">
+                    Edit Keys
+                </h2>
+            </div>
+        </div>
+    </div>
+</div>
+
+<div class="page-body">
+    <div class="container-xl">
+        <div class="row row-cards">
+            <div class="col-12">
+                <form asp-action="Edit" class="card">
+                    <div class="card-body">
+                        <div class="row">
+                            <div class="col-12">
+                                <div asp-validation-summary="ModelOnly" class="text-danger"></div>
+
+                                <div class="mb-3 textarea-grow-wrap">
+                                    <textarea asp-for="Keys" class="form-control" oninput="this.parentNode.dataset.replicatedValue = this.value">
+                                        @Model.Keys
+                                    </textarea>
+                                    <span asp-validation-for="Keys" class="text-danger"></span>
+                                </div>
+
+                                <input type="hidden" asp-for="Game.Id" />
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="card-footer">
+                        <div class="d-flex">
+                            <a asp-action="Details" asp-route-id="@Model.Game.Id" class="btn btn-ghost-primary">Cancel</a>
+                            <button type="submit" class="btn btn-primary ms-auto">Save</button>
+                        </div>
+                    </div>
+                </form>
+            </div>
+        </div>
+    </div>
+</div>
+
+<style>
+    .textarea-grow-wrap {
+        display: grid;
+    }
+
+    .textarea-grow-wrap::after {
+        content: attr(data-replicated-value) " ";
+        white-space: pre-wrap;
+        visibility: hidden;
+
+        width: 100%;
+        padding: .4375rem .75rem;
+        font-family: var(--tblr-font-sans-serif);
+        font-size: .875rem;
+        font-weight: 400;
+        line-height: 1.4285714286;
+        color: inherit;
+        background-color: var(--tblr-bg-forms);
+        background-clip: padding-box;
+        border: var(--tblr-border-width) solid var(--tblr-border-color);
+    }
+
+    .textarea-grow-wrap > textarea {
+        resize: none;
+        overflow: hidden;
+    }
+
+    .textarea-grow-wrap > textarea,
+    .textarea-grow-wrap::after {
+        grid-area: 1 / 1 / 2 / 2;
+    }
+</style>
+
+<script>
+    let growers = document.querySelectorAll(".textarea-grow-wrap");
+
+    growers.forEach((grower) => {
+        let textarea = grower.querySelector("textarea");
+
+        grower.dataset.replicatedValue = textarea.value;
+    });
+</script>
+
+@section Scripts {
+    @{ await Html.RenderPartialAsync("_ValidationScriptsPartial"); }
+}