/// <summary>
/// Get my private key
/// </summary>
/// <param name="keyType">Key type</param>
/// <param name="me">Me</param>
/// <returns>Private key</returns>
public async Task <string> GetPrivateKeyAsync(KeyTypeEnum keyType)
{
this.logger.LogDebug($"Start load {keyType.ToString()} private key from MemoryCache...");
try
{
var key = this.memoryCache.Get <CipherKey>(CacheKeyFactory.GetKeyCipher(keyType));
if (key != null)
{
this.logger.LogDebug($"Successfully load {keyType.ToString()} private key from MemoryCache. {key.ToString()}");
return(await Task.FromResult(key?.PrivateKey));
}
else
{
this.logger.LogWarning($"Failed to load {keyType.ToString()} private key from MemoryCache.");
throw new NullReferenceException($"No available {keyType.ToString()} private key");
}
}
catch (Exception ex)
{
this.logger.LogError(ex, $"{nameof(KeyManager)} error");
await this.showAllSavedKeyTypes();
return(string.Empty);
}
}
/// <summary>
/// Create a default RSA public key
/// </summary>
/// <param name="receiver">The target receiver</param>
/// <param name="isSender">Is </param>
/// <returns>CipherKey object</returns>
/// <remarks>This method will be used when cannot get receiver's public key from KMS</remarks>
public async Task <CipherKey> CreateDefaultAsymmetricKey(KeyTypeEnum keyType, bool isIncludePrivateKey = true)
{
switch (keyType)
{
case KeyTypeEnum.RSA:
using (var rsa = new RsaService())
{
return(await rsa.CreateKeyAsync());
}
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Get current working key
/// </summary>
/// <param name="keyType">Key type</param>
/// <returns>CipherKey object</returns>
public async Task <CipherKey> GetKeyAsync(KeyTypeEnum keyType)
{
this.logger.LogDebug($"Start load my {keyType.ToString()} key from MemoryCache.");
try
{
var key = this.memoryCache.Get <CipherKey>(CacheKeyFactory.GetKeyCipher(keyType));
this.logger.LogDebug($"Successfully load {keyType.ToString()} key from MemoryCache. {key.ToString()}");
return(await Task.FromResult(key));
}
catch (Exception ex)
{
this.logger.LogError(ex, $"{nameof(KeyManager)} error");
await this.showAllSavedKeyTypes();
return(null);
}
}
public string ProvideKey(KeyTypeEnum keyType, object[] parameters, IHttpContextAccessor httpContextAccessor, string inParamKey)
{
string result;
switch (keyType)
{
case KeyTypeEnum.FirstParam:
result = parameters[0]?.ToString();
break;
case KeyTypeEnum.SecondParam:
result = parameters[1]?.ToString();
break;
case KeyTypeEnum.ThirdParam:
result = parameters[2]?.ToString();
break;
case KeyTypeEnum.AllParam:
result = string.Join("-", parameters.Select(x => ConvertString(x)));
break;
case KeyTypeEnum.InParam:
result = GetInParam(parameters, inParamKey);
break;
case KeyTypeEnum.ClientIp:
result = GetIp(httpContextAccessor);
break;
default:
result = string.Empty;
break;
}
return(result);
}
/// <summary>
/// Key for Secret key
/// </summary>
/// <return>Cache key</return>
public static string GetKeyCipher(KeyTypeEnum keyType) => $"{KeyPrefixCipher}-{keyType.ToString()}";
protected ComparisonKey(KeyTypeEnum keyType, LibraryKey libraryKey)
{
LibraryKey = libraryKey;
KeyType = keyType;
}
public PrimaryKeyAttribute(KeyTypeEnum keyType = KeyTypeEnum.Manual)
{
this.KeyType = keyType;
}
public Task LoadKeyAsync(byte[] mifareKey, KeyTypeEnum keySlotNumber = 0)
{
return(Reader.LoadKeyAsync(mifareKey, keySlotNumber));
}
private async Task SaveKeyAsync <T>(KeyTypeEnum keyType, T key)
{
this.memoryCache.Set(CacheKeyFactory.GetKeyCipher(keyType), key);
this.logger.LogDebug($"Successfully sync {keyType.ToString()} key(s) from KMS.");
await Task.CompletedTask;
}
public Task Authenticate(int sector, int datablock, KeyTypeEnum keytype)
{
return(mfStdAccess.Authenticate(GetblockAddress(sector, datablock),
(keytype == KeyTypeEnum.KeyA) ? GeneralAuthenticate.GeneralAuthenticateKeyType.MifareKeyA : GeneralAuthenticate.GeneralAuthenticateKeyType.PicoTagPassKeyB,
(byte)keytype));
}
public Task LoadKeyAsync(byte[] mifareKey, KeyTypeEnum keySlotNumber = 0)
{
return(mfStdAccess.LoadKeyAsync(mifareKey, (byte)keySlotNumber));
}
