public async Task <IActionResult> AddApiKey([Required] string clientPublicKey, AuthType authType)
{
if (string.IsNullOrWhiteSpace(clientPublicKey))
{
ModelState.AddModelError(nameof(clientPublicKey), "Required");
}
clientPublicKey = _auth.CleanupKeyString(clientPublicKey);
var authFormat = AuthKeyFormatResolver.Resolve(clientPublicKey);
if (!authFormat.HasValue)
{
ModelState.AddModelError(nameof(clientPublicKey), "Invalid format");
}
if (ModelState.IsValid)
{
var pub = await _auth.GetOrAdd(new PublicKey()
{
Value = clientPublicKey, Type = authType, Format = authFormat.Value
});
var existing = await _auth.GetApiKey(pub);
if (existing == null)
{
var apiKey = await _auth.GenApiKey(pub, HandshakeMethod.Default);
}
}
return(RedirectToAction(nameof(Integrations)));
}
public async Task <PublicKey> GetOrAdd(PublicKey key)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
var hasValue = false;
if (!string.IsNullOrWhiteSpace(key.Value))
{
key.Value = key.Value.Replace("\r", "");
hasValue = true;
var resolvedFormat = AuthKeyFormatResolver.Resolve(key.Value);
if (!resolvedFormat.HasValue)
{
throw new ArgumentException($"Input key does not resolve to a valid format");
}
else if (key.Format == AuthKeyFormat.Error)
{
key.Format = resolvedFormat.Value;
}
else if (key.Format != resolvedFormat)
{
throw new ArgumentException($"Input key format ({key.Format}) does not match resolved format ({resolvedFormat})");
}
}
var original = key.Id > 0 ? await _db.PublicKeys.FindAsync(key.Id) : hasValue ? await _db.PublicKeys.FirstOrDefaultAsync(k => k.Type == key.Type && k.Format == key.Format && k.Value == key.Value) : null;
if (original == null)
{
key.FingerPrint = ComputeFingerPrint(key, FingerPrintType.MD5);
key.WhenAdded = DateTime.UtcNow;
await _db.PublicKeys.AddAsync(key);
await _db.SaveChangesAsync();
original = key;
}
if (string.IsNullOrWhiteSpace(original.FingerPrint))
{
key.FingerPrint = ComputeFingerPrint(key, FingerPrintType.MD5);
await _db.SaveChangesAsync();
}
return(original);
}
public async Task <AuthKeyResult> TryAddUserKey(PublicKey authKey, UserProfileModel user)
{
if (authKey == null)
{
throw new ArgumentNullException(nameof(authKey));
}
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (authKey.Id == 0)
{
authKey.Value = authKey.Value.Replace("\r", "");
var resolvedFormat = AuthKeyFormatResolver.Resolve(authKey.Value);
if (!resolvedFormat.HasValue)
{
throw new ArgumentException($"Input key does not resolve to a valid format");
}
else if (authKey.Format == AuthKeyFormat.Error)
{
authKey.Format = resolvedFormat.Value;
}
else if (authKey.Format != resolvedFormat)
{
throw new ArgumentException($"Input key format ({authKey.Format}) does not match resolved format ({resolvedFormat})");
}
}
Regex validator = null;
switch (authKey.Type)
{
case AuthType.OpenPGP: validator = RegexHelper.OpenPGPKeyRegex; break;
case AuthType.RSA: validator = RegexHelper.RSAKeyRegex; break;
}
if (validator != null && validator.IsMatch(authKey.Value))
{
var newKey = await GetOrAdd(authKey);
if (newKey != null)
{
var existing = await _db.UserAuthKeys.FirstOrDefaultAsync(k => k.UserId == user.Id && k.PublicKeyId == newKey.Id);
if (existing == null)
{
_db.UserAuthKeys.Add(new UserAuthKeyModel()
{
PublicKeyId = newKey.Id,
UserId = user.Id,
});
await _db.SaveChangesAsync();
}
}
return(new AuthKeyResult()
{
Error = AuthKeyError.None
});
}
else
{
return(new AuthKeyResult()
{
Error = AuthKeyError.InvalidFormat
});
}
}
