public void OnValueChanged(GXDLMSViewArguments arg)
{
if (arg.Index == 2)
{
if (arg.Value is byte[] && (arg.Value as byte[]).Length == 6)
{
GXBitString bs = new GXBitString(GXBitString.ToBitString((byte[])arg.Value, 0, 16));
int val = Convert.ToUInt16(bs);
ValuesLb.ItemCheck -= ValuesLb_ItemCheck;
for (int pos = 0; pos != 16; ++pos)
{
ValuesLb.SetItemChecked(pos, bs.Value[pos] == '1');
}
ValuesLb.ItemCheck += ValuesLb_ItemCheck;
GXByteBuffer bb = new GXByteBuffer((byte[])arg.Value);
bb.Position = 2;
DurationTb.Text = bb.GetUInt32().ToString();
HexTb.Text = bb.ToString();
}
else
{
DurationTb.Text = HexTb.Text = "";
ValuesLb.ItemCheck -= ValuesLb_ItemCheck;
for (int pos = 0; pos != 16; ++pos)
{
ValuesLb.SetItemChecked(pos, false);
}
ValuesLb.ItemCheck += ValuesLb_ItemCheck;
}
}
else
{
throw new IndexOutOfRangeException("index");
}
}
private void ValuesLb_ItemCheck(object sender, ItemCheckEventArgs e)
{
try
{
if (DurationTb.Text != "")
{
UInt32 dur = UInt32.Parse(DurationTb.Text);
StringBuilder sb = new StringBuilder();
for (int pos = 0; pos != 16; ++pos)
{
if (e != null && e.Index == pos)
{
sb.Append(e.NewValue == CheckState.Checked ? "1" : "0");
}
else
{
if (ValuesLb.GetItemChecked(pos))
{
sb.Append("1");
}
else
{
sb.Append("0");
}
}
}
GXBitString bs = new GXBitString(sb.ToString());
GXByteBuffer bb = new GXByteBuffer();
bb.SetUInt16(Convert.ToUInt16(bs));
bb.SetUInt32(dur);
(Target as GXDLMSData).Value = bb.Array();
errorProvider1.SetError((Control)sender, Properties.Resources.ValueChangedTxt);
Target.UpdateDirty(2, bb.Array());
HexTb.Text = bb.ToString();
}
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/**
* Convert system title to subject.
*
* @param systemTitle
* System title.
* @return Subject.
*/
public static string SystemTitleToSubject(byte[] systemTitle)
{
GXByteBuffer bb = new GXByteBuffer(systemTitle);
return("CN=" + bb.ToString());
}
/// <summary>
/// Decrypt data.
/// </summary>
/// <param name="p">Decryption parameters</param>
/// <returns>Decrypted data.</returns>
public static byte[] DecryptAesGcm(AesGcmParameter p, GXByteBuffer data)
{
if (data == null || data.Size < 2)
{
throw new ArgumentOutOfRangeException("cryptedData");
}
byte[] tmp;
int len;
Command cmd = (Command)data.GetUInt8();
switch (cmd)
{
case Command.GeneralGloCiphering:
case Command.GeneralDedCiphering:
len = GXCommon.GetObjectCount(data);
if (len != 0)
{
p.SystemTitle = new byte[len];
data.Get(p.SystemTitle);
if (p.Xml != null && p.Xml.Comments)
{
p.Xml.AppendComment(GXCommon.SystemTitleToString(Standard.DLMS, p.SystemTitle, true));
}
}
if (p.SystemTitle == null || p.SystemTitle.Length != 8)
{
if (p.Xml == null)
{
throw new ArgumentNullException("Invalid sender system title.");
}
else
{
p.Xml.AppendComment("Invalid sender system title.");
}
}
break;
case Command.GeneralCiphering:
case Command.GloInitiateRequest:
case Command.GloInitiateResponse:
case Command.GloReadRequest:
case Command.GloReadResponse:
case Command.GloWriteRequest:
case Command.GloWriteResponse:
case Command.GloGetRequest:
case Command.GloGetResponse:
case Command.GloSetRequest:
case Command.GloSetResponse:
case Command.GloMethodRequest:
case Command.GloMethodResponse:
case Command.GloEventNotification:
case Command.DedInitiateRequest:
case Command.DedInitiateResponse:
case Command.DedGetRequest:
case Command.DedGetResponse:
case Command.DedSetRequest:
case Command.DedSetResponse:
case Command.DedMethodRequest:
case Command.DedMethodResponse:
case Command.DedEventNotification:
case Command.DedReadRequest:
case Command.DedReadResponse:
case Command.DedWriteRequest:
case Command.DedWriteResponse:
case Command.GloConfirmedServiceError:
case Command.DedConfirmedServiceError:
break;
default:
throw new ArgumentOutOfRangeException("cryptedData");
}
int value = 0;
GXPrivateKey key = null;
GXPublicKey pub = null;
GXByteBuffer transactionId = null;
if (cmd == Command.GeneralCiphering)
{
transactionId = new GXByteBuffer();
len = GXCommon.GetObjectCount(data);
GXCommon.SetObjectCount(len, transactionId);
transactionId.Set(data, len);
p.TransactionId = transactionId.GetUInt64(1);
len = GXCommon.GetObjectCount(data);
if (len != 0)
{
tmp = new byte[len];
data.Get(tmp);
p.SystemTitle = tmp;
}
if (p.SystemTitle == null || p.SystemTitle.Length != 8)
{
if (p.Xml == null)
{
throw new ArgumentNullException("Invalid sender system title.");
}
else
{
p.Xml.AppendComment("Invalid sender system title.");
}
}
len = GXCommon.GetObjectCount(data);
tmp = new byte[len];
data.Get(tmp);
p.RecipientSystemTitle = tmp;
// Get date time.
len = GXCommon.GetObjectCount(data);
if (len != 0)
{
tmp = new byte[len];
data.Get(tmp);
p.DateTime = tmp;
}
// other-information
len = data.GetUInt8();
if (len != 0)
{
tmp = new byte[len];
data.Get(tmp);
p.OtherInformation = tmp;
}
// KeyInfo OPTIONAL
len = data.GetUInt8();
// AgreedKey CHOICE tag.
data.GetUInt8();
// key-parameters
len = data.GetUInt8();
value = data.GetUInt8();
p.KeyParameters = value;
if (value == (int)KeyAgreementScheme.OnePassDiffieHellman)
{
// key-ciphered-data
len = GXCommon.GetObjectCount(data);
GXByteBuffer bb = new GXByteBuffer();
bb.Set(data, len);
if (p.Xml != null)
{
p.KeyCipheredData = bb.Array();
//Find key agreement key using subject.
string subject = GXAsn1Converter.SystemTitleToSubject(p.SystemTitle);
foreach (KeyValuePair <GXPkcs8, GXx509Certificate> it in p.Settings.Keys)
{
if (it.Key != null && it.Value.KeyUsage == ASN.Enums.KeyUsage.KeyAgreement && it.Value.Subject.Contains(subject))
{
key = it.Key.PrivateKey;
//Get recipient Ephemeral public key.
subject = GXAsn1Converter.SystemTitleToSubject(p.RecipientSystemTitle);
foreach (KeyValuePair <GXPkcs8, GXx509Certificate> it2 in p.Settings.Keys)
{
if (it2.Value != null && it2.Value.KeyUsage == ASN.Enums.KeyUsage.KeyAgreement && it2.Value.Subject.Contains(subject))
{
pub = it2.Value.PublicKey;
break;
}
}
break;
}
}
if (key == null)
{
//Find key agreement key using subject.
subject = GXAsn1Converter.SystemTitleToSubject(p.RecipientSystemTitle);
foreach (KeyValuePair <GXPkcs8, GXx509Certificate> it in p.Settings.Keys)
{
if (it.Key != null && it.Value.KeyUsage == ASN.Enums.KeyUsage.KeyAgreement && it.Value.Subject.Contains(subject))
{
key = it.Key.PrivateKey;
break;
}
}
}
}
else
{
key = p.Settings.Cipher.KeyAgreementKeyPair.Key;
}
if (key != null && pub == null)
{
//Get Ephemeral public key.
int keySize = len / 2;
pub = GXPublicKey.FromRawBytes(bb.SubArray(0, keySize));
}
}
else if (value == (int)KeyAgreementScheme.StaticUnifiedModel)
{
len = GXCommon.GetObjectCount(data);
if (len != 0)
{
throw new ArgumentException("Invalid key parameters");
}
if (p.Xml != null)
{
//Find key agreement key using subject.
string subject = GXAsn1Converter.SystemTitleToSubject(p.RecipientSystemTitle);
foreach (KeyValuePair <GXPkcs8, GXx509Certificate> it in p.Settings.Keys)
{
if (it.Value.KeyUsage == ASN.Enums.KeyUsage.KeyAgreement && it.Value.Subject.Contains(subject))
{
key = it.Key.PrivateKey;
break;
}
}
if (key != null)
{
//Find key agreement key using subject.
subject = GXAsn1Converter.SystemTitleToSubject(p.Settings.SourceSystemTitle);
foreach (KeyValuePair <GXPkcs8, GXx509Certificate> it in p.Settings.Keys)
{
if (it.Value.KeyUsage == ASN.Enums.KeyUsage.KeyAgreement && it.Value.Subject.Contains(subject))
{
pub = it.Value.PublicKey;
break;
}
}
}
}
else
{
key = p.Settings.Cipher.KeyAgreementKeyPair.Key;
pub = p.Settings.Cipher.KeyAgreementKeyPair.Value;
}
}
else
{
throw new ArgumentException("key-parameters");
}
}
len = GXCommon.GetObjectCount(data);
if (len > data.Available)
{
throw new Exception("Not enought data.");
}
p.CipheredContent = data.Remaining();
byte sc = data.GetUInt8();
p.SecuritySuite = (SecuritySuite)(sc & 0x3);
p.Security = (Security)(sc & 0x30);
if ((sc & 0x80) != 0)
{
System.Diagnostics.Debug.WriteLine("Compression is used.");
}
if ((sc & 0x40) != 0)
{
System.Diagnostics.Debug.WriteLine("Error: Key_Set is used.");
}
if ((sc & 0x20) != 0)
{
System.Diagnostics.Debug.WriteLine("Encryption is applied.");
}
if (key != null)
{
if (value == (int)KeyAgreementScheme.OnePassDiffieHellman)
{
GXEcdsa c = new GXEcdsa(key);
//Get Ephemeral signing key and verify it.
byte[] z = c.GenerateSecret(pub);
System.Diagnostics.Debug.WriteLine("Originator ephemeral public key: " + pub.ToHex());
System.Diagnostics.Debug.WriteLine("Recipient private agreement key: " + key.ToHex());
System.Diagnostics.Debug.WriteLine("Shared secret:" + GXCommon.ToHex(z, true));
GXByteBuffer kdf = new GXByteBuffer();
kdf.Set(GXSecure.GenerateKDF(p.SecuritySuite, z,
p.SecuritySuite == SecuritySuite.Ecdsa256 ? AlgorithmId.AesGcm128 : AlgorithmId.AesGcm256,
p.SystemTitle,
p.RecipientSystemTitle,
null, null));
System.Diagnostics.Debug.WriteLine("KDF:" + kdf.ToString());
p.BlockCipherKey = kdf.SubArray(0, 16);
}
else if (value == (int)KeyAgreementScheme.StaticUnifiedModel)
{
GXEcdsa c = new GXEcdsa(key);
byte[] z = c.GenerateSecret(pub);
System.Diagnostics.Debug.WriteLine("Shared secret:" + GXCommon.ToHex(z, true));
GXByteBuffer kdf = new GXByteBuffer();
kdf.Set(GXSecure.GenerateKDF(p.SecuritySuite, z,
p.SecuritySuite == SecuritySuite.Ecdsa256 ? AlgorithmId.AesGcm128 : AlgorithmId.AesGcm256,
p.SystemTitle,
transactionId.Array(),
p.RecipientSystemTitle,
null));
System.Diagnostics.Debug.WriteLine("KDF:" + kdf.ToString());
p.BlockCipherKey = kdf.SubArray(0, 16);
}
else
{
throw new ArgumentOutOfRangeException("Invalid Key-id value.");
}
}
UInt32 invocationCounter = data.GetUInt32();
p.InvocationCounter = invocationCounter;
System.Diagnostics.Debug.WriteLine("Decrypt settings: " + p.ToString());
System.Diagnostics.Debug.WriteLine("Encrypted: " + GXCommon.ToHex(data.Data,
false, data.Position, data.Size - data.Position));
byte[] tag = new byte[12];
byte[] encryptedData;
int length;
if (p.Security == Security.Authentication)
{
length = data.Size - data.Position - 12;
encryptedData = new byte[length];
data.Get(encryptedData);
data.Get(tag);
// Check tag.
EncryptAesGcm(p, encryptedData);
if (!GXDLMSChipperingStream.TagsEquals(tag, p.CountTag))
{
if (p.Xml == null)
{
throw new GXDLMSException("Decrypt failed. Invalid tag.");
}
else
{
p.Xml.AppendComment("Decrypt failed. Invalid tag.");
}
}
return(encryptedData);
}
byte[] ciphertext = null;
if (p.Security == Security.Encryption)
{
length = data.Size - data.Position;
ciphertext = new byte[length];
data.Get(ciphertext);
}
else if (p.Security == Security.AuthenticationEncryption)
{
length = data.Size - data.Position - 12;
ciphertext = new byte[length];
data.Get(ciphertext);
data.Get(tag);
}
byte[] aad = GetAuthenticatedData(p, ciphertext),
iv = GetNonse(invocationCounter, p.SystemTitle);
GXDLMSChipperingStream gcm = new GXDLMSChipperingStream(p.Security, true,
p.BlockCipherKey, aad, iv, tag);
gcm.Write(ciphertext);
byte[] decrypted = gcm.FlushFinalBlock();
System.Diagnostics.Debug.WriteLine("Decrypted: " + GXCommon.ToHex(decrypted, true));
if (p.Security != Security.Encryption)
{
if (!GXCommon.Compare(gcm.GetTag(), tag))
{
if (p.Xml == null)
{
throw new Exception("Decrypt failed. Invalid authentication tag.");
}
p.Xml.AppendComment("Decrypt failed. Invalid authentication tag.");
}
}
return(decrypted);
}
/// <summary>
/// Update ephemeral keys.
/// </summary>
/// <param name="client">DLMS Client.</param>
/// <param name="value">Received reply from the server.</param>
/// <returns>List of Parsed key id and GUAK. This is for debugging purpose.</returns>
public List <KeyValuePair <GlobalKeyType, byte[]> > UpdateEphemeralKeys(GXDLMSSecureClient client, GXByteBuffer value)
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
if (value.GetUInt8() != (byte)DataType.Array)
{
throw new ArgumentOutOfRangeException("Invalid tag.");
}
GXEcdsa c = new GXEcdsa(client.Ciphering.EphemeralKeyPair.Key);
int count = GXCommon.GetObjectCount(value);
List <KeyValuePair <GlobalKeyType, byte[]> > list = new List <KeyValuePair <GlobalKeyType, byte[]> >();
for (int pos = 0; pos != count; ++pos)
{
if (value.GetUInt8() != (byte)DataType.Structure)
{
throw new ArgumentOutOfRangeException("Invalid tag.");
}
if (value.GetUInt8() != 2)
{
throw new ArgumentOutOfRangeException("Invalid length.");
}
if (value.GetUInt8() != (byte)DataType.Enum)
{
throw new ArgumentOutOfRangeException("Invalid key id data type.");
}
int keyId = value.GetUInt8();
if (keyId > 4)
{
throw new ArgumentOutOfRangeException("Invalid key type.");
}
if (value.GetUInt8() != (byte)DataType.OctetString)
{
throw new ArgumentOutOfRangeException("Invalid tag.");
}
if (GXCommon.GetObjectCount(value) != 128)
{
throw new ArgumentOutOfRangeException("Invalid length.");
}
//Get ephemeral public key server.
GXByteBuffer key = new GXByteBuffer();
key.SetUInt8(4);
key.Set(value, 64);
GXPublicKey targetEphemeralKey = GXPublicKey.FromRawBytes(key.Array());
//Get ephemeral public key signature server.
byte[] signature = new byte[64];
value.Get(signature);
key.SetUInt8(0, (byte)keyId);
//Verify signature.
if (!GXSecure.ValidateEphemeralPublicKeySignature(key.Array(), signature, client.Ciphering.SigningKeyPair.Value))
{
throw new GXDLMSCipherException("Invalid signature.");
}
byte[] z = c.GenerateSecret(targetEphemeralKey);
System.Diagnostics.Debug.WriteLine("Shared secret:" + GXCommon.ToHex(z, true));
GXByteBuffer kdf = new GXByteBuffer();
kdf.Set(GXSecure.GenerateKDF(client.SecuritySuite, z,
AlgorithmId.AesGcm128,
client.Ciphering.SystemTitle,
client.Settings.SourceSystemTitle, null, null));
System.Diagnostics.Debug.WriteLine("KDF:" + kdf.ToString());
list.Add(new KeyValuePair <GlobalKeyType, byte[]>((GlobalKeyType)keyId, kdf.SubArray(0, 16)));
}
//Update ephemeral keys.
foreach (KeyValuePair <GlobalKeyType, byte[]> it in list)
{
switch (it.Key)
{
case GlobalKeyType.UnicastEncryption:
client.Settings.EphemeralBlockCipherKey = it.Value;
break;
case GlobalKeyType.BroadcastEncryption:
client.Settings.EphemeralBroadcastBlockCipherKey = it.Value;
break;
case GlobalKeyType.Authentication:
client.Settings.EphemeralAuthenticationKey = it.Value;
break;
case GlobalKeyType.Kek:
client.Settings.EphemeralKek = it.Value;
break;
}
}
return(list);
}
