public static void StartCheckKeysTask(NodeKeysDto paramNodeKeys, KeyLength keyLength, uint lifeTime)
{
Task.Run(async() =>
{
while (true)
{
try
{
NodeKeysDto nodeKeys = await AppServiceProvider.Instance.KeysService.GetActualNodeKeysAsync(NodeSettings.Configs.Node.Id).ConfigureAwait(false);
if (nodeKeys == null ||
(nodeKeys.ExpirationTime - DateTime.UtcNow.ToUnixTime()) <= TimeSpan.FromDays(5).TotalSeconds)
{
nodeKeys = await AppServiceProvider.Instance.KeysService.CreateNewNodeKeysAsync(NodeSettings.Configs.Node.Id, keyLength, lifeTime).ConfigureAwait(false);
if (paramNodeKeys == null)
{
paramNodeKeys = nodeKeys;
}
Console.WriteLine($"New keys was generated. KeyId: {nodeKeys.KeyId}");
await NodeData.NodeNoticeService.SendNewNodeKeysNodeNoticeAsync(nodeKeys.PublicKey, nodeKeys.SignPublicKey, nodeKeys.KeyId, nodeKeys.ExpirationTime).ConfigureAwait(false);
await LicensorClient.Instance.AddNewKeyAsync(nodeKeys.PublicKey, nodeKeys.SignPublicKey, nodeKeys.KeyId, nodeKeys.ExpirationTime, nodeKeys.GenerationTime, true).ConfigureAwait(false);
}
paramNodeKeys = nodeKeys;
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
finally
{
await Task.Delay(TimeSpan.FromSeconds(60)).ConfigureAwait(true);
}
}
}).Wait(TimeSpan.FromSeconds(5));
}
public static string GetKeyAlphaNumeric(KeyLength l)
{
Guid g = Guid.NewGuid();
string randStr = g.ToString("N");
string tracStr = randStr.Substring(0, (int)l);
tracStr = tracStr.ToUpper();
char[] newKey = tracStr.ToCharArray();
string newAlphaNumKey = String.Empty;
switch (l)
{
case KeyLength.l16:
newAlphaNumKey = AppendStr(16, "-", newKey);
break;
case KeyLength.l20:
newAlphaNumKey = AppendStr(20, "-", newKey);
break;
case KeyLength.l24:
newAlphaNumKey = AppendStr(24, "-", newKey);
break;
case KeyLength.l28:
newAlphaNumKey = AppendStr(28, "-", newKey);
break;
case KeyLength.l32:
newAlphaNumKey = AppendStr(32, "-", newKey);
break;
}
return(newAlphaNumKey);
}
public KeyDerivationParameters(KeyDerivationPrf derivationFunction, IterationCount iterationCount,
SaltLength saltLength, KeyLength keyLength)
{
DerivationFunction = derivationFunction;
IterationCount = iterationCount;
SaltLength = saltLength;
KeyLength = keyLength;
}
private OnetSkill GetOnetAttribute(CategoryType type, int id, KeyLength keyLength)
{
var keyId = $"{id}-A.B.C.D";
return(new OnetSkill {
Id = $"{keyId.Substring(0, (int) keyLength)}", OnetOccupationalCode = "testONetCode", Score = id, Category = type, Name = $"Name-{type}-{id}"
});
}
public void VerifyHexKeyCreation(string hexKey, string expectedKey, KeyLength expectedLength, KeyScheme expectedScheme)
{
var key = new HexKey(hexKey);
Assert.AreEqual(expectedKey, key.Key);
Assert.AreEqual(expectedLength, key.Length);
Assert.AreEqual(expectedScheme, key.Scheme);
Assert.AreEqual(key.ToString().StripKeyScheme(), hexKey.ToUpper().StripKeyScheme());
}
/// <summary>
/// Create a key that can be passed into the constructor, and used for
/// encrypting and decrypting data.
/// </summary>
/// <param name="keyLength"></param>
/// <returns></returns>
public static byte[] CreateKey(KeyLength keyLength = KeyLength.K128)
{
using (var aes = new RNGCryptoServiceProvider())
{
byte[] bytes = new byte[(int)keyLength];
aes.GetBytes(bytes);
return bytes;
}
}
void ReleaseDesignerOutlets()
{
if (CancelButton != null)
{
CancelButton.Dispose();
CancelButton = null;
}
if (CreateKey != null)
{
CreateKey.Dispose();
CreateKey = null;
}
if (FilePath != null)
{
FilePath.Dispose();
FilePath = null;
}
if (KeyLength != null)
{
KeyLength.Dispose();
KeyLength = null;
}
if (OkButton != null)
{
OkButton.Dispose();
OkButton = null;
}
if (OpenFileButton != null)
{
OpenFileButton.Dispose();
OpenFileButton = null;
}
if (PrivateKeyOptions != null)
{
PrivateKeyOptions.Dispose();
PrivateKeyOptions = null;
}
if (PrivateKeyTextView != null)
{
PrivateKeyTextView.Dispose();
PrivateKeyTextView = null;
}
}
public String DES_Decrypt(DesMode mode, KeyLength length, int keyVariant, KeyPair pair, String key, String data, String IV = "")
{
String command = String.Empty;
String commandCode = "ZC";
String msg = String.Empty;
int commandLength = 0;
if (mode == DesMode.CBC && IV == "")
{
throw new Exception("CBC mode need IV value.");
}
if ((length == KeyLength.Single && key.Length != 16) ||
(length == KeyLength.Double && key.Length != 32))
{
throw new Exception("Key length error.");
}
if ((data.Length / 2) % 8 != 0)
{
throw new Exception("Data length must in multiples of 8 bytes.");
}
commandLength = 10 + key.Length + IV.Length / 2 + 3 + data.Length / 2;
command = header + commandCode + ((int)mode).ToString() + ((int)length).ToString()
+ keyVariant.ToString() + ((int)pair).ToString() + key;
command = Convert.ToString(commandLength, 16).PadLeft(4, '0')
+ BitConverter.ToString(Encoding.ASCII.GetBytes(command)).Replace("-", "");
command += IV;
command += BitConverter.ToString(Encoding.ASCII.GetBytes((data.Length / 2).ToString("000"))).Replace("-", "");
command += data;
send(SoapHexBinary.Parse(command).Value);
msg = getResponse();
if (msg.Substring(16, 4) != "3030")
{
ReturnErrorMsg(msg.Substring(16, 4));
}
return(msg.Substring(20));
}
public override void AwakeFromNib()
{
base.AwakeFromNib();
KeyLength.SelectItem(0);
FilePath.Enabled = false;
OpenFileButton.Enabled = false;
//Events
CreateKey.Activated += OnClickCreateKey;
OpenFileButton.Activated += OpenKeyFile;
OkButton.Activated += OnClickOkButton;
CancelButton.Activated += (object sender, EventArgs e) => {
this.Close();
NSApplication.SharedApplication.StopModalWithCode(0);
};
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="key_length">AES key length</param>
public AES(KeyLength key_length)
{
if (key_length == KeyLength.AES128)
{
Nk = 4;
Nr = 10;
Round_key = new byte[176];
}
else if (key_length == KeyLength.AES192)
{
Nk = 6;
Nr = 12;
Round_key = new byte[208];
}
else if (key_length == KeyLength.AES256)
{
Nk = 8;
Nr = 14;
Round_key = new byte[240];
}
}
public MyRC5(uint numberOfRounds, KeyLength keyLength, uint wordLength)
{
_numberOfRounds = (int) numberOfRounds;
//_keyLength = keyLength;
_wordLength = wordLength;
switch (keyLength)
{
case KeyLength.KEY_LENGTH_16:
_pw = P_16;
_qw = Q_16;
break;
case KeyLength.KEY_LENGTH_32:
_pw = P_32;
_qw = Q_32;
break;
case KeyLength.KEY_LENGTH_64:
_pw = P_64;
_qw = Q_64;
break;
}
_myRandom = new MyRandom(31, 2147483647, 16807, 17711);
_myMd5 = new MyMD5();
}
public HexKey(string key)
{
if (key.Length == 16)
{
PartA = key;
PartB = key;
PartC = key;
keyLength = KeyLength.SingleLength;
}
else if (key.Length == 32)
{
PartA = key.Substring(0, 16);
PartB = key.Substring(16);
PartC = PartA;
keyLength = KeyLength.DoubleLength;
}
else if (key.Length == 48)
{
PartA = key.Substring(0, 16);
PartB = key.Substring(16, 16);
PartC = key.Substring(32);
keyLength = KeyLength.TripleLength;
}
}
public HexKey(string key)
{
if ((key == null) || (key == ""))
{
throw new Exceptions.XInvalidKey("Invalid key data: " + key);
}
if ((key.Length == 17) || (key.Length == 33) || (key.Length == 49))
{
_scheme = KeySchemeTable.GetKeySchemeFromValue(key.Substring(0, 1));
if ((_scheme != KeySchemeTable.KeyScheme.DoubleLengthKeyAnsi) &&
(_scheme != KeySchemeTable.KeyScheme.DoubleLengthKeyVariant) &&
(_scheme != KeySchemeTable.KeyScheme.SingleDESKey) &&
(_scheme != KeySchemeTable.KeyScheme.TripleLengthKeyAnsi) &&
(_scheme != KeySchemeTable.KeyScheme.TripleLengthKeyVariant))
{
throw new Exceptions.XInvalidKeyScheme("Invalid key scheme " + key.Substring(0, 1));
}
else
{
key = key.Substring(1);
}
}
else
{
if (key.Length == 16)
{
_scheme = KeySchemeTable.KeyScheme.SingleDESKey;
}
else if (key.Length == 32)
{
_scheme = KeySchemeTable.KeyScheme.DoubleLengthKeyAnsi;
}
else
{
_scheme = KeySchemeTable.KeyScheme.TripleLengthKeyAnsi;
}
}
if (Utility.IsHexString(key) == false)
{
throw new Exceptions.XInvalidKey("Invalid key data: " + key);
}
if (key.Length == 16)
{
_partA = key;
_partB = key;
_partC = key;
_keyLength = KeyLength.SingleLength;
}
else if (key.Length == 32)
{
_partA = key.Substring(0, 16);
_partB = key.Substring(16);
_partC = _partA;
_keyLength = KeyLength.DoubleLength;
}
else if (key.Length == 48)
{
_partA = key.Substring(0, 16);
_partB = key.Substring(16, 16);
_partC = key.Substring(32);
_keyLength = KeyLength.TripleLength;
}
else
{
throw new Exceptions.XInvalidKey("Invalid key length: " + key);
}
}
public string GetApdu(byte keySlot, KeyType keyType, Persistence persistence, Transmission transmissionType, KeyLength keyLength, string key)
{
key = key.Replace(" ", "").Replace("-", "");
byte keyStructure = 0x00;
switch (keyType)
{
case KeyType.CardKey:
break;
case KeyType.ReaderKey:
keyStructure |= (1 << 7);
break;
default:
throw new ArgumentOutOfRangeException(nameof(keyType), keyType, null);
}
switch (transmissionType)
{
case Transmission.Plain:
break;
// ToDo add more cases for transmission of encrypted key content if any reader support this feature
default:
throw new ArgumentOutOfRangeException(nameof(transmissionType), transmissionType, null);
}
switch (persistence)
{
case Persistence.Volatile:
break;
case Persistence.Persistent:
keyStructure |= (1 << 5);
break;
default:
throw new ArgumentOutOfRangeException(nameof(persistence), persistence, null);
}
switch (keyLength)
{
case KeyLength._6Bytes:
case KeyLength._8Bytes:
case KeyLength._16Bytes:
case KeyLength._24Bytes:
case KeyLength._32Bytes:
if ((int)keyLength == Utilities.BinaryHelper.ConvertOctetStringToBytes(key).Length)
{
break;
}
throw new ArgumentException("Key length incorrect", nameof(key));
default:
throw new ArgumentOutOfRangeException(nameof(keyLength), keyLength, null);
}
return("FF82" + keyStructure.ToString("X2") + keySlot.ToString("X2") + ((byte)keyLength).ToString("X2") + key);
}
public void TestKeyLength(string key, KeyLength expected)
{
Assert.AreEqual(expected, key.GetKeyLength());
}
public void GenerateHashAndSalt_ReturnsHash_WithNumberOfBytesEqualToKeyLengthParameter()
{
// Arrange
var iterationCount = 10_000;
var saltLength = 16;
var keyLength = 64;
var parameters = new KeyDerivationParameters(KeyDerivationPrf.HMACSHA512,
IterationCount.From(iterationCount), SaltLength.From(saltLength), KeyLength.From(keyLength));
var rng = Substitute.For <ICryptoRng>();
rng.GetRandomBytes(Arg.Any <int>()).Returns(args => new byte[args.Arg <int>()]);
var service = new PasswordService(parameters, rng);
// Act
var hash = service.GeneratePasswordHashAndSalt(PlaintextPassword.From("somePassword"));
// Assert
Assert.AreEqual(keyLength, Convert.FromBase64String(hash.Base64PasswordHash.Value).Length);
}
public async Task <NodeKeysDto> CreateNewNodeKeysAsync(long?nodeId, KeyLength keyLength, uint lifetime)
{
byte[] password;
using (SHA256 sha256 = SHA256.Create())
{
password = sha256.ComputeHash(Encoding.UTF8.GetBytes(NodeSettings.Configs.Password));
}
long keyId = RandomExtensions.NextInt64();
using (MessengerDbContext context = contextFactory.Create())
{
var nodeKeysId = await context.NodesKeys
.Where(opt => opt.NodeId == nodeId)
.Select(opt => opt.KeyId)
.ToListAsync()
.ConfigureAwait(false);
while (nodeKeysId.Contains(keyId))
{
keyId = RandomExtensions.NextInt64();
}
byte[] symmetricKey = Encryptor.GetSymmetricKey(256, keyId, lifetime, password);
Encryptor.KeyLengthType encKeysLength;
Encryptor.KeyLengthType signKeysLength;
switch (keyLength)
{
case KeyLength.Short:
encKeysLength = Encryptor.KeyLengthType.EncryptShort;
signKeysLength = Encryptor.KeyLengthType.SignShort;
break;
case KeyLength.Medium:
encKeysLength = Encryptor.KeyLengthType.EncryptMedium;
signKeysLength = Encryptor.KeyLengthType.SignMedium;
break;
case KeyLength.Long:
default:
encKeysLength = Encryptor.KeyLengthType.EncryptLong;
signKeysLength = Encryptor.KeyLengthType.SignLong;
break;
}
var asymKeys = Encryptor.GenerateAsymmetricKeys(keyId, lifetime, encKeysLength, password);
var signAsymKeys = Encryptor.GenerateAsymmetricKeys(keyId, lifetime, signKeysLength, password);
long generationTime = DateTime.UtcNow.ToUnixTime();
NodeKeys nodeKeys = new NodeKeys
{
GenerationTime = generationTime,
ExpirationTime = generationTime + lifetime,
KeyId = keyId,
NodeId = nodeId.GetValueOrDefault(),
PublicKey = asymKeys.FirstValue,
PrivateKey = asymKeys.SecondValue,
SymmetricKey = symmetricKey,
SignPublicKey = signAsymKeys.FirstValue,
SignPrivateKey = signAsymKeys.SecondValue
};
await context.AddAsync(nodeKeys).ConfigureAwait(false);
await context.SaveChangesAsync().ConfigureAwait(false);
return(new NodeKeysDto
{
ExpirationTime = nodeKeys.ExpirationTime,
GenerationTime = nodeKeys.GenerationTime,
KeyId = nodeKeys.KeyId,
NodeId = nodeKeys.NodeId,
PrivateKey = nodeKeys.PrivateKey,
PublicKey = nodeKeys.PublicKey,
SymmetricKey = nodeKeys.SymmetricKey,
SignPublicKey = nodeKeys.SignPublicKey,
SignPrivateKey = nodeKeys.SignPrivateKey,
Password = password
});
}
}
public void GenerateHashAndSalt_ThenCheckingOtherPassword_ReturnsFalse()
{
// Arrange
var iterationCount = 10_000;
var saltLength = 16;
var keyLength = 64;
var parameters = new KeyDerivationParameters(KeyDerivationPrf.HMACSHA512,
IterationCount.From(iterationCount), SaltLength.From(saltLength), KeyLength.From(keyLength));
var rng = Substitute.For <ICryptoRng>();
rng.GetRandomBytes(Arg.Any <int>()).Returns(args => new byte[args.Arg <int>()]);
var service = new PasswordService(parameters, rng);
var password = PlaintextPassword.From("somePass");
var otherPass = PlaintextPassword.From("otherPass");
// Act
var hash = service.GeneratePasswordHashAndSalt(password);
var checkResult = service.CheckIfPasswordMatchesHash(otherPass, hash);
// Assert
Assert.IsFalse(checkResult);
}
