public async Task <AuthKeyResult> GenKey(AuthKeyOptions options, HandshakeMethod method)
{
var ret = await _typeHandlers[options.Type][options.Format].GenerateKey(method);
ret.Public.Value = ret.Public.Value.Replace("\r", "");
if (string.IsNullOrWhiteSpace(ret.Public.FingerPrint))
{
ret.Public.FingerPrint = ComputeFingerPrint(ret.Public, FingerPrintType.MD5);
}
await _db.PublicKeys.AddAsync(ret.Public);
await _db.SaveChangesAsync();
ret.Private.PublicKeyId = ret.Public.Id;
throw new Exception();
//await _db.PrivateKeys.AddAsync(ret.Private);
await _db.SaveChangesAsync();
return(new AuthKeyResult()
{
Keys = ret,
Error = AuthKeyError.None,
});
}
public async Task <KeyPair> GenerateKey(HandshakeMethod method)
{
var tmpFilePublic = System.IO.Path.GetTempFileName();
var tmpFilePrivate = System.IO.Path.GetTempFileName();
using var pgp = new PGP();
await pgp.GenerateKeyAsync(tmpFilePublic, tmpFilePrivate);
var publicKey = await File.ReadAllTextAsync(tmpFilePublic);
var privateKey = await File.ReadAllTextAsync(tmpFilePrivate);
return(new KeyPair()
{
Private = new PrivateKey()
{
Format = AuthKeyFormat.PEM,
Type = Type,
Value = privateKey,
WhenAdded = DateTime.UtcNow,
},
Public = new PublicKey()
{
Format = AuthKeyFormat.PEM,
Type = Type,
Value = publicKey.Trim(),
WhenAdded = DateTime.UtcNow,
},
});
}
public override Task <KeyPair> GenerateKey(HandshakeMethod method)
{
var randomGenerator = new CryptoApiRandomGenerator();
var secureRandom = new SecureRandom(randomGenerator);
var keyGenerationParameters = new KeyGenerationParameters(secureRandom, 1024);
var keyPairGenerator = new RsaKeyPairGenerator();
keyPairGenerator.Init(keyGenerationParameters);
var pair = keyPairGenerator.GenerateKeyPair();
string privateKey;
using (var writer = new StringWriter())
{
var pemWriter = new PemWriter(writer);
pemWriter.WriteObject(pair.Private);
pemWriter.Writer.Flush();
privateKey = writer.ToString();
}
string publicKey;
using (var writer = new StringWriter())
{
var pemWriter = new PemWriter(writer);
pemWriter.WriteObject(pair.Public);
pemWriter.Writer.Flush();
publicKey = writer.ToString();
}
return(Task.FromResult(new KeyPair()
{
Public = new PublicKey()
{
Value = publicKey,
Format = Format,
Type = Type,
},
Private = new PrivateKey()
{
Value = privateKey,
Format = Format,
Type = Type,
},
}));
}
public override Task <KeyPair> GenerateKey(HandshakeMethod method)
{
var _rsa = new RSACryptoServiceProvider();
var rsaKeyInfo = _rsa.ExportParameters(true);
return(Task.FromResult(new KeyPair()
{
Public = new PublicKey()
{
Value = Convert.ToBase64String(_rsa.ExportSubjectPublicKeyInfo()),
Format = Format,
Type = Type,
},
Private = new PrivateKey()
{
Value = Convert.ToBase64String(_rsa.ExportRSAPrivateKey()),
Format = Format,
Type = Type,
},
}));
}
public async Task <AuthKeyResult> GenApiKey(PublicKey clientKey, HandshakeMethod method)
{
if (clientKey == null || clientKey.Id <= 0 || string.IsNullOrWhiteSpace(clientKey.Value))
{
throw new ArgumentNullException(nameof(clientKey));
}
var key = await GenKey(new AuthKeyOptions()
{
Format = clientKey.Format, Type = clientKey.Type
}, method);
if (key.Error == AuthKeyError.None)
{
await _db.ApiAuthKeys.AddAsync(new ApiAuthKeyModel()
{
ServerPrivateKeyId = key.Keys.Private.Id, ServerPublicKeyId = key.Keys.Public.Id, ClientPublicKeyId = clientKey.Id
});
await _db.SaveChangesAsync();
}
return(key);
}
public abstract Task <KeyPair> GenerateKey(HandshakeMethod method);
public bool HandshakeMethodSupported(HandshakeMethod method) => method == HandshakeMethod.Default;
public async Task <IActionResult> SendInviteViaMethod(HandshakeMethod method, int id)
{
var code = await _invitationService.GetAccessCodeAsync(id);
var model = new SendInviteViaMethodViewModel()
{
MyProfile = await GetCurrentUserAsync(),
};
switch (method)
{
case HandshakeMethod.Email:
{
var subject = string.Empty;
var action = "join";
switch (code.Type)
{
case InvitationType.Register:
subject = _settings.Site.HostDisplayName;
break;
case InvitationType.FollowMe:
{
UserProfileModel user;
if (model.MyProfile.UserId == code.CreatedByUserId)
{
user = await _localProfiles.GetUser(model.MyProfile.UserId.Value, model.MyProfile.UserId);
}
else
{
user = await _localProfiles.GetUser(code.CreatedByUserId, model.MyProfile.UserId);
}
subject = $"{user.DisplayName} @{user.Handle}";
} break;
case InvitationType.AddMeToGroup:
subject = code.GroupName;
break;
}
subject = Uri.EscapeDataString($"Invitation to {action} {subject}");
var body = Uri.EscapeDataString(code.GroupName);
model.Link = $"mailto:[email protected]?body={body}&subject={subject}";
} break;
case HandshakeMethod.Link:
model.Link = $"/Account/AcceptInvite/{code.Code}";
break;
case HandshakeMethod.ManualCodeMachine:
model.RawString = code.Code;
break;
case HandshakeMethod.ManualCodeHuman:
if (Guid.TryParse(code.Code, out var asGuid))
{
model.RawString = string.Join(' ', _auth.ToBiometric(asGuid.ToByteArray()));
}
else
{
model.RawString = code.Code;
}
break;
case HandshakeMethod.QRCode:
{
QRCodeGenerator qrGenerator = new QRCodeGenerator();
QRCodeData qrCodeData = qrGenerator.CreateQrCode("The text which should be encoded.", QRCodeGenerator.ECCLevel.Q);
Base64QRCode qrCode = new Base64QRCode(qrCodeData);
model.QRCodeImageAsBase64 = qrCode.GetGraphic(20);
} break;
default:
throw new Exception($"Invalid method {method}");
}
return(View(model));
}
public bool HandshakeMethodSupported(HandshakeMethod mehod)
{
return(false);
}
