private SenderKeyState(uint id, uint iteration, byte[] chainKey,
ECPublicKey signatureKeyPublic,
May <ECPrivateKey> signatureKeyPrivate)
{
SenderKeyStateStructure.Types.SenderChainKey senderChainKeyStructure =
SenderKeyStateStructure.Types.SenderChainKey.CreateBuilder()
.SetIteration(iteration)
.SetSeed(ByteString.CopyFrom(chainKey))
.Build();
SenderKeyStateStructure.Types.SenderSigningKey.Builder signingKeyStructure =
SenderKeyStateStructure.Types.SenderSigningKey.CreateBuilder()
.SetPublic(ByteString.CopyFrom(signatureKeyPublic.Serialize()));
if (signatureKeyPrivate.HasValue)
{
signingKeyStructure.SetPrivate(ByteString.CopyFrom(signatureKeyPrivate.ForceGetValue().Serialize()));
}
this.senderKeyStateStructure = SenderKeyStateStructure.CreateBuilder()
.SetSenderKeyId(id)
.SetSenderChainKey(senderChainKeyStructure)
.SetSenderSigningKey(signingKeyStructure)
.Build();
}
public PreKeyWhisperMessage(uint messageVersion, uint registrationId, May <uint> preKeyId,
uint signedPreKeyId, ECPublicKey baseKey, IdentityKey identityKey,
WhisperMessage message)
{
this.version = messageVersion;
this.registrationId = registrationId;
this.preKeyId = preKeyId;
this.signedPreKeyId = signedPreKeyId;
this.baseKey = baseKey;
this.identityKey = identityKey;
this.message = message;
WhisperProtos.PreKeyWhisperMessage.Builder builder =
WhisperProtos.PreKeyWhisperMessage.CreateBuilder()
.SetSignedPreKeyId(signedPreKeyId)
.SetBaseKey(ByteString.CopyFrom(baseKey.Serialize()))
.SetIdentityKey(ByteString.CopyFrom(identityKey.Serialize()))
.SetMessage(ByteString.CopyFrom(message.Serialize()))
.SetRegistrationId(registrationId);
if (preKeyId.HasValue) // .isPresent()
{
builder.SetPreKeyId(preKeyId.ForceGetValue()); // get()
}
byte[] versionBytes = { ByteUtil.IntsToByteHighAndLow((int)this.version, (int)CURRENT_VERSION) };
byte[] messageBytes = builder.Build().ToByteArray();
this.serialized = ByteUtil.Combine(versionBytes, messageBytes);
}
public void SetUnacknowledgedPreKeyMessage(May <uint> preKeyId, uint signedPreKeyId, ECPublicKey baseKey)
{
PendingPreKey.Builder pending = PendingPreKey.CreateBuilder()
.SetSignedPreKeyId(signedPreKeyId)
.SetBaseKey(ByteString.CopyFrom(baseKey.Serialize()));
if (preKeyId.HasValue)
{
pending.SetPreKeyId(preKeyId.ForceGetValue());
}
this.sessionStructure = this.sessionStructure.ToBuilder()
.SetPendingPreKey(pending.Build())
.Build();
}
public SenderKeyDistributionMessage(uint id, uint iteration, byte[] chainKey, ECPublicKey signatureKey)
{
byte[] version = { ByteUtil.IntsToByteHighAndLow((int)CURRENT_VERSION, (int)CURRENT_VERSION) };
byte[] protobuf = WhisperProtos.SenderKeyDistributionMessage.CreateBuilder()
.SetId(id)
.SetIteration(iteration)
.SetChainKey(ByteString.CopyFrom(chainKey))
.SetSigningKey(ByteString.CopyFrom(signatureKey.Serialize()))
.Build().ToByteArray();
this.id = id;
this.iteration = iteration;
this.chainKey = chainKey;
this.signatureKey = signatureKey;
this.serialized = ByteUtil.Combine(version, protobuf);
}
public void AddReceiverChain(ECPublicKey senderRatchetKey, ChainKey chainKey)
{
Chain.Types.ChainKey chainKeyStructure = Chain.Types.ChainKey.CreateBuilder()
.SetKey(ByteString.CopyFrom(chainKey.GetKey()))
.SetIndex(chainKey.GetIndex())
.Build();
Chain chain = Chain.CreateBuilder()
.SetChainKey(chainKeyStructure)
.SetSenderRatchetKey(ByteString.CopyFrom(senderRatchetKey.Serialize()))
.Build();
this.sessionStructure = this.sessionStructure.ToBuilder().AddReceiverChains(chain).Build();
if (this.sessionStructure.ReceiverChainsList.Count > 5)
{
this.sessionStructure = this.sessionStructure.ToBuilder() /*.ClearReceiverChains()*/.Build(); //RemoveReceiverChains(0) TODO: why does it work without
}
}
public WhisperMessage(uint messageVersion, byte[] macKey, ECPublicKey senderRatchetKey,
uint counter, uint previousCounter, byte[] ciphertext,
IdentityKey senderIdentityKey,
IdentityKey receiverIdentityKey)
{
byte[] version = { ByteUtil.IntsToByteHighAndLow((int)messageVersion, (int)CURRENT_VERSION) };
byte[] message = WhisperProtos.WhisperMessage.CreateBuilder()
.SetRatchetKey(ByteString.CopyFrom(senderRatchetKey.Serialize()))
.SetCounter(counter)
.SetPreviousCounter(previousCounter)
.SetCiphertext(ByteString.CopyFrom(ciphertext))
.Build().ToByteArray();
byte[] mac = GetMac(messageVersion, senderIdentityKey, receiverIdentityKey, macKey,
ByteUtil.Combine(version, message));
this.serialized = ByteUtil.Combine(version, message, mac);
this.senderRatchetKey = senderRatchetKey;
this.counter = counter;
this.previousCounter = previousCounter;
this.ciphertext = ciphertext;
this.messageVersion = messageVersion;
}
public byte[] Serialize()
{
return(publicKey.Serialize());
}
public KeyExchangeMessage(uint messageVersion, uint sequence, uint flags,
ECPublicKey baseKey, byte[] baseKeySignature,
ECPublicKey ratchetKey,
IdentityKey identityKey)
{
this.supportedVersion = CipherTextMessage.CURRENT_VERSION;
this.version = messageVersion;
this.sequence = sequence;
this.flags = flags;
this.baseKey = baseKey;
this.baseKeySignature = baseKeySignature;
this.ratchetKey = ratchetKey;
this.identityKey = identityKey;
byte[] version = { ByteUtil.IntsToByteHighAndLow((int)this.version, (int)this.supportedVersion) };
WhisperProtos.KeyExchangeMessage.Builder builder = WhisperProtos.KeyExchangeMessage
.CreateBuilder()
.SetId((sequence << 5) | flags) //(sequence << 5) | flags
.SetBaseKey(ByteString.CopyFrom(baseKey.Serialize()))
.SetRatchetKey(ByteString.CopyFrom(ratchetKey.Serialize()))
.SetIdentityKey(ByteString.CopyFrom(identityKey.Serialize()));
if (messageVersion >= 3)
{
builder.SetBaseKeySignature(ByteString.CopyFrom(baseKeySignature));
}
this.serialized = ByteUtil.Combine(version, builder.Build().ToByteArray());
}