public static void CreateNew(ICryptoLibrary cryptoLibrary, out RegistrationPrivateKey privateKey, out RegistrationId registrationId)
{
privateKey = new RegistrationPrivateKey {
ed25519privateKey = cryptoLibrary.GeneratePrivateKeyEd25519()
};
registrationId = new RegistrationId(cryptoLibrary.GetPublicKeyEd25519(privateKey.ed25519privateKey));
}
private void CryptoClientForm_Load(object sender, EventArgs e)
{
// add algoritams in drop down
ToolStripMenuItem menu = new ToolStripMenuItem("Algorithams");
ToolStripMenuItem item = new ToolStripMenuItem("Substitution");
ICryptoLibrary alg = new SimpleSubstitution();
item.Tag = alg;
this.algorithm = alg;
menu.DropDownItems.Add(item);
alg = new XXTEA();
item = new ToolStripMenuItem("XXTEA");
item.Tag = alg;
menu.DropDownItems.Add(item);
alg = new SHA2();
item = new ToolStripMenuItem("SHA2");
item.Tag = alg;
menu.DropDownItems.Add(item);
// TODO: add Knapsack
menu.DropDownItemClicked += new System.Windows.Forms.ToolStripItemClickedEventHandler(this.OnClickedItem);
this.msOptions.Items.Add(menu);
this.Init();
}
/// <param name="ack1SdIsReady">
/// =true for SD in ACK2
/// =false for SD in ACK1 (since the SessionDescription is not initialized yet)
/// </param>
internal byte[] Encrypt(ICryptoLibrary cryptoLibrary, InviteRequestPacket req, InviteAck1Packet ack1, InviteSession session,
bool ack1SdIsReady
)
{
BinaryProcedures.CreateBinaryWriter(out var ms, out var w);
w.Write(Flags);
UserCertificate.Encode(w, false);
BinaryProcedures.EncodeIPEndPoint(w, DirectChannelEndPoint);
NatBehaviour.Encode(w);
DirectChannelToken32.Encode(w);
w.Write((byte)SessionType);
UserCertificateSignature.Encode(w);
var bytesInLastBlock = (int)ms.Position % CryptoLibraries.AesBlockSize;
if (bytesInLastBlock != 0)
{
var bytesRemainingTillFullAesBlock = CryptoLibraries.AesBlockSize - bytesInLastBlock;
w.Write(cryptoLibrary.GetRandomBytes(bytesRemainingTillFullAesBlock));
}
var plainTextSdData = ms.ToArray();
var encryptedSdData = new byte[plainTextSdData.Length];
#region key, iv
BinaryProcedures.CreateBinaryWriter(out var ms2, out var w2);
req.GetSharedSignedFields(w2);
ack1.GetSharedSignedFields(w2, ack1SdIsReady);
var iv = cryptoLibrary.GetHashSHA256(ms2.ToArray()).Take(16).ToArray();
ms2.Write(session.SharedInviteAckDhSecret, 0, session.SharedInviteAckDhSecret.Length);
var aesKey = cryptoLibrary.GetHashSHA256(ms2.ToArray()); // here SHA256 is used as KDF, together with common fields from packets, including both ECDH public keys and timestamp
#endregion
cryptoLibrary.ProcessAesCbcBlocks(true, aesKey, iv, plainTextSdData, encryptedSdData);
return(encryptedSdData);
}
public static LocalDrpPeerConfiguration Create(ICryptoLibrary cryptoLibrary, int?numberOfDimensions = null, byte[] ed25519privateKey = null, RegistrationId registrationId = null)
{
LocalDrpPeerConfiguration r;
if (ed25519privateKey != null && registrationId != null)
{
r = new LocalDrpPeerConfiguration
{
LocalPeerRegistrationPrivateKey = new RegistrationPrivateKey {
ed25519privateKey = ed25519privateKey
},
LocalPeerRegistrationId = registrationId
};
}
else
{
RegistrationId.CreateNew(cryptoLibrary, out var newPrivateKey, out var newRegistrationId);
r = new LocalDrpPeerConfiguration
{
LocalPeerRegistrationPrivateKey = newPrivateKey,
LocalPeerRegistrationId = newRegistrationId
};
}
if (numberOfDimensions == 2)
{
r.MinDesiredNumberOfNeighbors = 5;
r.SoftMaxNumberOfNeighbors = 7;
r.AbsoluteMaxNumberOfNeighbors = 10;
}
return(r);
}
public static Ike1Invitation CreateNew(ICryptoLibrary cryptoLibrary, RegistrationId registrationId)
{
return(new Ike1Invitation
{
ContactInvitationToken = cryptoLibrary.GetRandomBytes(InviteRequestPacket.ContactInvitationTokenSize),
InvitationInitiatorRegistrationId = registrationId
});
}
private void CryptoClientForm_Load(object sender, EventArgs e)
{
this.tbSrcPath.Text = ".\\" + this.defaultSrcPath;
this.tbDstPath.Text = ".\\" + this.defaultDstPath;
this.defaultSrcPath = AppDomain.CurrentDomain.BaseDirectory.ToString() + this.defaultSrcPath;
this.defaultDstPath = AppDomain.CurrentDomain.BaseDirectory.ToString() + this.defaultDstPath;
string[] srcDicFiles = Directory.GetFiles(this.defaultSrcPath);
foreach (string f in srcDicFiles)
{
this.lbFilesToEncrypt.Items.Add(f);
}
string[] dstDicFiles = Directory.GetFiles(this.defaultDstPath);
foreach (string f in dstDicFiles)
{
this.lbEncryptedFiles.Items.Add(f);
}
this.CreateNewFileWatcher();
ICryptoLibrary[] algorithams = new ICryptoLibrary[4];
algorithams[0] = new SimpleSubstitution();
algorithams[1] = new XXTEA();
algorithams[2] = new SHA2();
algorithams[3] = new Knapsack();
specs = new Dictionary <string, byte[]>();
// add algoritams in drop down
ToolStripMenuItem menu = new ToolStripMenuItem("Algorithams");
ToolStripMenuItem item;
for (int i = 0; i < algorithams.Length; i++)
{
item = new ToolStripMenuItem(algorithams[i].ToString());
item.Tag = algorithams[i];
menu.DropDownItems.Add(item);
if (i == 0)
{
this.algoritham = algorithams[i];
}
}
menu.DropDownItemClicked += new System.Windows.Forms.ToolStripItemClickedEventHandler(this.OnClickedItem);
this.msOptions.Items.Add(menu);
this.Init();
tbN.KeyPress += this.tbKey_KeyPress;
tbM.KeyPress += this.tbKey_KeyPress;
tbIM.KeyPress += this.tbKey_KeyPress;
lbHint.Visible = false;
}
public static RegistrationSignature DecodeAndVerify(BinaryReader reader, ICryptoLibrary cryptoLibrary, Action <BinaryWriter> writeSignedFields, RegistrationId publicKey)
{
var r = Decode(reader);
if (!r.Verify(cryptoLibrary, writeSignedFields, publicKey))
{
throw new BadSignatureException("invalid registration signature 135");
}
return(r);
}
public static RegistrationSignature Sign(ICryptoLibrary cryptoLibrary, Action <BinaryWriter> writeSignedFields, RegistrationPrivateKey privateKey)
{
var r = new RegistrationSignature();
var ms = new MemoryStream(); using (var writer = new BinaryWriter(ms)) writeSignedFields(writer);
r.ed25519signature = cryptoLibrary.SignEd25519(
ms.ToArray(),
privateKey.ed25519privateKey);
return(r);
}
public bool Verify(ICryptoLibrary cryptoLibrary, Action <BinaryWriter> writeSignedFields, RegistrationId publicKey)
{
var signedData = new MemoryStream();
using (var writer = new BinaryWriter(signedData))
writeSignedFields(writer);
if (cryptoLibrary.VerifyEd25519(signedData.ToArray(), ed25519signature, publicKey.Ed25519publicKey) == false)
{
return(false);
}
return(true);
}
public static double GetMutualP2pConnectionValue(ICryptoLibrary cryptoLibrary, RegistrationId registrationId1, ushort neighborsBusySectorIds1,
RegistrationId registrationId2, ushort neighborsBusySectorIds2, int numberOfDimensions,
bool thisConnectionAlreadyExists, bool anotherNeighborToSameSectorExists1, bool anotherNeighborToSameSectorExists2, bool allowConnectionsToSameRegistrationId)
{
if (registrationId1.Equals(registrationId2))
{
return(allowConnectionsToSameRegistrationId ? SameRegistrationIdConnectionValue : -SameRegistrationIdConnectionValue);
}
double r = 0;
var distance = registrationId1.GetDistanceTo(cryptoLibrary, registrationId2, numberOfDimensions).ToDouble();
r -= distance;
if (thisConnectionAlreadyExists)
{
if (anotherNeighborToSameSectorExists1 == false)
{
r += EmptySectorOccupationValue;
}
if (anotherNeighborToSameSectorExists2 == false)
{
r += EmptySectorOccupationValue;
}
}
else
{
var vsic = new VectorSectorIndexCalculator(numberOfDimensions);
var vector1to2 = RegistrationId.GetDifferenceVectorF(registrationId1, registrationId2, cryptoLibrary, numberOfDimensions);
var vector1to2SectorIndex = vsic.GetSectorIndex(vector1to2);
var vector1to2IsInVacantSector = ((neighborsBusySectorIds1 >> vector1to2SectorIndex) & 0x0001) == 0;
if (vector1to2IsInVacantSector)
{
r += EmptySectorOccupationValue;
}
var vector2to1 = new float[numberOfDimensions];
for (int i = 0; i < numberOfDimensions; i++)
{
vector2to1[i] = -vector1to2[i];
}
var vector2to1SectorIndex = vsic.GetSectorIndex(vector2to1);
var vector2to1IsInVacantSector = ((neighborsBusySectorIds2 >> vector2to1SectorIndex) & 0x0001) == 0;
if (vector2to1IsInVacantSector)
{
r += EmptySectorOccupationValue;
}
}
return(r);
}
private void OnClickedItem(object sender, ToolStripItemClickedEventArgs e)
{
this.algorithm = (ICryptoLibrary)e.ClickedItem.Tag;
byte[] key;
if (this.algorithm.GetType() != typeof(SHA2))
{
key = this.algorithm.GenerateRandomKey();
}
else
{
key = ((SHA2)this.algorithm).GetKey();
}
this.tbKey.Text = System.Text.Encoding.UTF8.GetString(key);
}
internal byte[] EncryptShortSingleMessage(ICryptoLibrary cryptoLibrary, string messageText)
{
if (Status != MessageSessionStatusCode.inProgress)
{
throw new InvalidOperationException();
}
var decryptedMessageData = MessageEncoderDecoder.EncodePlainTextMessageWithPadding_plainTextUtf8_256(cryptoLibrary, messageText);
var encryptedMessageData = new byte[decryptedMessageData.Length];
cryptoLibrary.ProcessAesCbcBlocks(true, _aesKey, _iv, decryptedMessageData, encryptedMessageData);
Status = MessageSessionStatusCode.encryptionDecryptionCompleted;
return(encryptedMessageData);
}
internal byte[] EncryptIke1Data(ICryptoLibrary cryptoLibrary, Ike1Data ike1Data)
{
if (Status != MessageSessionStatusCode.inProgress)
{
throw new InvalidOperationException();
}
var decryptedMessageData = MessageEncoderDecoder.EncodeIke1DataWithPadding(cryptoLibrary, ike1Data);
var encryptedMessageData = new byte[decryptedMessageData.Length];
cryptoLibrary.ProcessAesCbcBlocks(true, _aesKey, _iv, decryptedMessageData, encryptedMessageData);
Status = MessageSessionStatusCode.encryptionDecryptionCompleted;
return(encryptedMessageData);
}
internal void DeriveKeys(ICryptoLibrary cryptoLibrary, byte[] sharedPingPongHmacKey, MessageStartPacket messageStart,
byte[] directChannelSharedDhSecret)
{
if (Status != MessageSessionStatusCode.created)
{
throw new InvalidOperationException();
}
BinaryProcedures.CreateBinaryWriter(out var msE, out var wE);
messageStart.GetSignedFieldsForMessageHMAC(wE, false);
wE.Write(sharedPingPongHmacKey);
_iv = cryptoLibrary.GetHashSHA256(msE.ToArray()).Take(16).ToArray();
wE.Write(directChannelSharedDhSecret);
_aesKey = cryptoLibrary.GetHashSHA256(msE.ToArray());
Status = MessageSessionStatusCode.inProgress;
}
/// <param name="receivedFromUser">comes from local contact book. is null if it is contact invitation</param>
internal static InviteSessionDescription Decrypt_Verify(ICryptoLibrary cryptoLibrary, byte[] encryptedSdData,
InviteRequestPacket req,
InviteAck1Packet ack1,
bool ack1SdIsReady,
InviteSession session,
UserId receivedFromUserNullable,
DateTime localTimeNowUtc
)
{
#region key, iv
BinaryProcedures.CreateBinaryWriter(out var ms2, out var w2);
req.GetSharedSignedFields(w2);
ack1.GetSharedSignedFields(w2, ack1SdIsReady);
var iv = cryptoLibrary.GetHashSHA256(ms2.ToArray()).Take(16).ToArray();
ms2.Write(session.SharedInviteAckDhSecret, 0, session.SharedInviteAckDhSecret.Length);
var aesKey = cryptoLibrary.GetHashSHA256(ms2.ToArray()); // here SHA256 is used as KDF, together with common fields from packets, including both ECDH public keys and timestamp
#endregion
// decrypt
var plainTextSdData = new byte[encryptedSdData.Length];
cryptoLibrary.ProcessAesCbcBlocks(false, aesKey, iv, encryptedSdData, plainTextSdData);
var r = new InviteSessionDescription();
var reader = BinaryProcedures.CreateBinaryReader(plainTextSdData, 0);
r.Flags = reader.ReadByte();
if ((r.Flags & FlagsMask_MustBeZero) != 0)
{
throw new NotImplementedException();
}
r.UserCertificate = UserCertificate.Decode_AssertIsValidNow(reader, cryptoLibrary, receivedFromUserNullable, localTimeNowUtc);
r.DirectChannelEndPoint = BinaryProcedures.DecodeIPEndPoint(reader);
r.NatBehaviour = NatBehaviourModel.Decode(reader);
r.DirectChannelToken32 = DirectChannelToken32.Decode(reader);
r.SessionType = (SessionType)reader.ReadByte();
r.UserCertificateSignature = UserCertificateSignature.DecodeAndVerify(reader, cryptoLibrary,
w =>
{
req.GetSharedSignedFields(w);
ack1.GetSharedSignedFields(w, ack1SdIsReady);
r.WriteSignedFields(w);
},
r.UserCertificate);
return(r);
}
public static LocalDrpPeerConfiguration Create(ICryptoLibrary cryptoLibrary, int numberOfDimensions, byte[] ed25519privateKey = null, RegistrationId registrationId = null)
{
var privatekey = new RegistrationPrivateKey {
ed25519privateKey = ed25519privateKey ?? cryptoLibrary.GeneratePrivateKeyEd25519()
};
var r = new LocalDrpPeerConfiguration
{
LocalPeerRegistrationPrivateKey = privatekey,
LocalPeerRegistrationId = new RegistrationId(registrationId?.Ed25519publicKey ?? cryptoLibrary.GetPublicKeyEd25519(privatekey.ed25519privateKey))
};
if (numberOfDimensions == 2)
{
r.MinDesiredNumberOfNeighbors = 5;
r.SoftMaxNumberOfNeighbors = 7;
r.AbsoluteMaxNumberOfNeighbors = 10;
}
return(r);
}
public UserAppDatabase(ICryptoLibrary cryptoLibrary, IDatabaseKeyProvider keyProvider, VisionChannel visionChannel, string visionChannelSourceId, string basePathNullable)
{
_keyProvider = keyProvider;
_cryptoLibrary = cryptoLibrary;
_visionChannel = visionChannel;
_visionChannelSourceId = visionChannelSourceId;
if (basePathNullable == null)
{
basePathNullable = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
}
var mainDatabaseFileName = Path.Combine(basePathNullable, "dcomms_main.db");
WriteToLog_deepDetail($"basePath={basePathNullable}, databaseFileName={mainDatabaseFileName}");
_db_main = new SQLiteConnection(mainDatabaseFileName);
_db_main.CreateTable <User>(CreateFlags.None);
_db_main.CreateTable <RootUserKeys>(CreateFlags.None);
_db_main.CreateTable <UserRegistrationID>(CreateFlags.None);
WriteToLog_deepDetail($"initialized sqlite database");
}
internal static byte[] EncodePlainTextMessageWithPadding_plainTextUtf8_256(ICryptoLibrary cryptoLibrary, string messageText)
{
var messageTextData = Encoding.UTF8.GetBytes(messageText);
if (messageTextData.Length > 255)
{
throw new ArgumentException();
}
BinaryProcedures.CreateBinaryWriter(out var ms, out var w);
w.Write((byte)EncodedDataType.plainTextUtf8_256);
w.Write((byte)messageTextData.Length);
w.Write(messageTextData);
// add padding with random data
var bytesInLastBlock = (int)ms.Position % CryptoLibraries.AesBlockSize;
if (bytesInLastBlock != 0)
{
var bytesRemainingTillFullAesBlock = CryptoLibraries.AesBlockSize - bytesInLastBlock;
w.Write(cryptoLibrary.GetRandomBytes(bytesRemainingTillFullAesBlock));
}
return(ms.ToArray());
}
internal static byte[] EncodeIke1DataWithPadding(ICryptoLibrary cryptoLibrary, Ike1Data ike1Data)
{
BinaryProcedures.CreateBinaryWriter(out var ms, out var w);
byte flags = 0;
w.Write(flags);
ike1Data.UserId.Encode(w);
w.Write((byte)ike1Data.RegistrationIds.Length);
foreach (var localRegistrationId in ike1Data.RegistrationIds)
{
localRegistrationId.Encode(w);
}
// add padding with random data
var bytesInLastBlock = (int)ms.Position % CryptoLibraries.AesBlockSize;
if (bytesInLastBlock != 0)
{
var bytesRemainingTillFullAesBlock = CryptoLibraries.AesBlockSize - bytesInLastBlock;
w.Write(cryptoLibrary.GetRandomBytes(bytesRemainingTillFullAesBlock));
}
return(ms.ToArray());
}
double _distance_sumSqr; // 32 bytes of reg. public key: split into 16 dimensions of 2 bytes // euclidean distance
public unsafe RegistrationIdDistance(ICryptoLibrary cryptoLibrary, RegistrationId rpk1, RegistrationId rpk2, int numberOfDimensions)
{
if (rpk1.CachedEd25519publicKeySha256 == null)
{
rpk1.CachedEd25519publicKeySha256 = cryptoLibrary.GetHashSHA256(rpk1.Ed25519publicKey);
}
var rpk1_ed25519publicKey_sha256 = rpk1.CachedEd25519publicKeySha256;
if (rpk2.CachedEd25519publicKeySha256 == null)
{
rpk2.CachedEd25519publicKeySha256 = cryptoLibrary.GetHashSHA256(rpk2.Ed25519publicKey);
}
var rpk2_ed25519publicKey_sha256 = rpk2.CachedEd25519publicKeySha256;
if (rpk1_ed25519publicKey_sha256.Length != rpk2_ed25519publicKey_sha256.Length)
{
throw new ArgumentException();
}
_distance_sumSqr = 0;
if (numberOfDimensions == 16)
{
fixed(byte *rpk1a = rpk1_ed25519publicKey_sha256, rpk2a = rpk2_ed25519publicKey_sha256)
{
ushort *rpk1aPtr = (ushort *)rpk1a, rpk2aPtr = (ushort *)rpk2a;
int l = rpk1_ed25519publicKey_sha256.Length / 2;
for (int i = 0; i < l; i++, rpk1aPtr++, rpk2aPtr++)
{
var d_i = VectorComponentRoutine(*rpk1aPtr, *rpk2aPtr);
_distance_sumSqr += d_i * d_i;
}
}
}
else if (numberOfDimensions == 8)
{
fixed(byte *rpk1a = rpk1_ed25519publicKey_sha256, rpk2a = rpk2_ed25519publicKey_sha256)
{
uint *rpk1aPtr = (uint *)rpk1a, rpk2aPtr = (uint *)rpk2a;
int l = rpk1_ed25519publicKey_sha256.Length / 4;
for (int i = 0; i < l; i++, rpk1aPtr++, rpk2aPtr++)
{
var d_i = VectorComponentRoutine(*rpk1aPtr, *rpk2aPtr);
_distance_sumSqr += d_i * d_i;
}
}
}
else if (numberOfDimensions == 4)
{
fixed(byte *rpk1a = rpk1_ed25519publicKey_sha256, rpk2a = rpk2_ed25519publicKey_sha256)
{
ulong *rpk1aPtr = (ulong *)rpk1a, rpk2aPtr = (ulong *)rpk2a;
int l = rpk1_ed25519publicKey_sha256.Length / 8;
for (int i = 0; i < l; i++, rpk1aPtr++, rpk2aPtr++)
{
var d_i = VectorComponentRoutine(*rpk1aPtr, *rpk2aPtr);
_distance_sumSqr += d_i * d_i;
}
}
}
else if (numberOfDimensions == 2)
{
GetVectorValues_2(rpk1_ed25519publicKey_sha256, out var v1_0, out var v1_1);
GetVectorValues_2(rpk2_ed25519publicKey_sha256, out var v2_0, out var v2_1);
var d_0 = VectorComponentRoutine(v1_0, v2_0);
var d_1 = VectorComponentRoutine(v1_1, v2_1);
_distance_sumSqr += d_0 * d_0;
_distance_sumSqr += d_1 * d_1;
}
else
{
throw new NotImplementedException();
}
}
public static float[] GetDifferenceVectorF(RegistrationId from, RegistrationId to, ICryptoLibrary cryptoLibrary, int numberOfDimensions) => GetDifferenceVector(from, to, cryptoLibrary, numberOfDimensions).Select(x => (float)x).ToArray();
public static double[] GetDifferenceVector(RegistrationId from, RegistrationId to, ICryptoLibrary cryptoLibrary, int numberOfDimensions)
{
var fromRegIdVector = RegistrationIdDistance.GetVectorValues(cryptoLibrary, from, numberOfDimensions);
var destinationRegIdVector = RegistrationIdDistance.GetVectorValues(cryptoLibrary, to, numberOfDimensions);
var diff = new double[fromRegIdVector.Length];
for (int i = 0; i < diff.Length; i++)
{
diff[i] = RegistrationIdDistance.GetDifferenceInLoopedRegistrationIdSpace(fromRegIdVector[i], destinationRegIdVector[i]);
}
return(diff);
}
public RegistrationIdDistance GetDistanceTo(ICryptoLibrary cryptoLibrary, RegistrationId another, int numberOfDimensions) => new RegistrationIdDistance(cryptoLibrary, this, another, numberOfDimensions);
public static unsafe double[] GetVectorValues(ICryptoLibrary cryptoLibrary, RegistrationId rid, int numberOfDimensions)
{
var r = new double[numberOfDimensions];
if (rid.CachedEd25519publicKeySha256 == null)
{
rid.CachedEd25519publicKeySha256 = cryptoLibrary.GetHashSHA256(rid.Ed25519publicKey);
}
var rid_ed25519publicKey_sha256 = rid.CachedEd25519publicKeySha256;
if (numberOfDimensions == 16)
{
fixed(byte *rpk1a = rid_ed25519publicKey_sha256)
{
ushort *rpk1aPtr = (ushort *)rpk1a;
int l = rid_ed25519publicKey_sha256.Length / 2;
for (int i = 0; i < l; i++, rpk1aPtr++)
{
r[i] = (double)(*rpk1aPtr) / UInt16.MaxValue;
}
}
}
else if (numberOfDimensions == 8)
{
fixed(byte *rpk1a = rid_ed25519publicKey_sha256)
{
uint *rpk1aPtr = (uint *)rpk1a;
int l = rid_ed25519publicKey_sha256.Length / 4;
for (int i = 0; i < l; i++, rpk1aPtr++)
{
r[i] = (double)(*rpk1aPtr) / UInt32.MaxValue;
}
}
}
else if (numberOfDimensions == 4)
{
fixed(byte *rpk1a = rid_ed25519publicKey_sha256)
{
ulong *rpk1aPtr = (ulong *)rpk1a;
int l = rid_ed25519publicKey_sha256.Length / 8;
for (int i = 0; i < l; i++, rpk1aPtr++)
{
r[i] = (double)(*rpk1aPtr) / ulong.MaxValue;
}
}
}
else if (numberOfDimensions == 2)
{
GetVectorValues_2(rid_ed25519publicKey_sha256, out var v0, out var v1);
r[0] = v0;
r[1] = v1;
}
else
{
throw new NotImplementedException();
}
return(r);
}
private void OnClickedItem(object sender, ToolStripItemClickedEventArgs e)
{
if (algoritham.GetType() != ((ICryptoLibrary)e.ClickedItem.Tag).GetType())
{
this.algoritham = (ICryptoLibrary)e.ClickedItem.Tag;
byte[] key;
if (this.algoritham.GetType() != typeof(SHA2))
{
key = this.algoritham.GenerateRandomKey();
btnRandomGenerateKey.Enabled = true;
btnSetKey.Enabled = true;
btnDecode.Enabled = true;
btnDecryptAll.Enabled = true;
btnDecryptSeleced.Enabled = true;
btnDecodeFromFile.Enabled = true;
}
else
{
key = ((SHA2)this.algoritham).GetKey();
btnRandomGenerateKey.Enabled = false;
btnSetKey.Enabled = false;
btnDecode.Enabled = false;
btnDecryptAll.Enabled = false;
btnDecryptSeleced.Enabled = false;
btnDecodeFromFile.Enabled = false;
}
if (this.algoritham.GetType() != typeof(Knapsack))
{
gbKnapSackProp.Enabled = false;
//tbKey.Enabled = true;
tbKey.KeyPress -= this.tbKey_KeyPress;
lbHint.Visible = false;
}
else
{
// set up for knapsack
gbKnapSackProp.Enabled = true;
//tbKey.Enabled = false;
tbKey.KeyPress += this.tbKey_KeyPress;
tbN.Text = ((Knapsack)this.algoritham).n.ToString();
tbM.Text = ((Knapsack)this.algoritham).m.ToString();
tbIM.Text = ((Knapsack)this.algoritham).mInverse.ToString();
lbHint.Visible = true;
}
// encoding problem fixed like this :)
if (this.algoritham.GetType() != typeof(Knapsack))
{
this.tbKey.Text = new string(Encoding.Default.GetChars(key));
}
else
{
uint[] temp = new uint[key.Length / 4];
string tempKeyStr = string.Empty;
for (
int i = 0; i < key.Length; i += 4)
{
temp[i / 4] = BitConverter.ToUInt32(key, i);
tempKeyStr += " " + BitConverter.ToUInt32(key, i);
}
this.tbKey.Text = tempKeyStr;
//this.tbKey.Text = string.Join(", ", key.Select(x => x.ToString()).ToArray());
}
this.gbAlgorithm.Text = this.algoritham.ToString();
}
}
internal void DeriveSharedInviteAckDhSecret(ICryptoLibrary cryptoLibrary, byte[] remotePublicEcdheKey)
{
SharedInviteAckDhSecret = cryptoLibrary.DeriveEcdh25519SharedSecret(LocalInviteAckEcdhePrivateKey, remotePublicEcdheKey);
}
