signalapp/SignalMetadataKit
signalapp/SignalMetadataKit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'mkirk/wrap-exceptions'

Browse Source
This commit is contained in:
Michael Kirk 2018-10-30 11:15:46 -06:00
commit d6b0186cc5
9 changed files with 154 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
SignalMetadataKit/src/SMKCertificateValidator.swift
View File

@ -10,9 +10,9 @@ public enum SMKCertificateError: Error {
@objc public protocol SMKCertificateValidator: class {
@objc func validate(senderCertificate: SMKSenderCertificate, validationTime: UInt64) throws
@objc func throwswrapped_validate(senderCertificate: SMKSenderCertificate, validationTime: UInt64) throws
@objc func validate(serverCertificate: SMKServerCertificate) throws
@objc func throwswrapped_validate(serverCertificate: SMKServerCertificate) throws
}
// See: https://github.com/signalapp/libsignal-metadata-java/blob/master/java/src/main/java/org/signal/libsignal/metadata/certificate/CertificateValidator.java
@ -37,25 +37,25 @@ public enum SMKCertificateError: Error {
}
// public void validate(SenderCertificate certificate, long validationTime) throws InvalidCertificateException {
@objc public func validate(senderCertificate: SMKSenderCertificate, validationTime: UInt64) throws {
@objc public func throwswrapped_validate(senderCertificate: SMKSenderCertificate, validationTime: UInt64) throws {
// try {
// ServerCertificate serverCertificate = certificate.getSigner();
let serverCertificate = senderCertificate.signer
// validate(serverCertificate);
try validate(serverCertificate: serverCertificate)
try throwswrapped_validate(serverCertificate: serverCertificate)
// if (!Curve.verifySignature(serverCertificate.getKey(), certificate.getCertificate(), certificate.getSignature())) {
// throw new InvalidCertificateException("Signature failed");
// }
let certificateData = try senderCertificate.toProto().certificate
guard Ed25519.verifySignature(senderCertificate.signatureData,
publicKey: serverCertificate.key.keyData,
data: certificateData) else {
Logger.error("Sender certificate signature verification failed.")
let error = SMKCertificateError.invalidCertificate(description: "Sender certificate signature verification failed.")
Logger.error("\(error)")
throw error
guard try Ed25519.verifySignature(senderCertificate.signatureData,
publicKey: serverCertificate.key.keyData,
data: certificateData) else {
Logger.error("Sender certificate signature verification failed.")
let error = SMKCertificateError.invalidCertificate(description: "Sender certificate signature verification failed.")
Logger.error("\(error)")
throw error
}
// if (validationTime > certificate.getExpiration()) {
@ -74,7 +74,7 @@ public enum SMKCertificateError: Error {
// // VisibleForTesting
// void validate(ServerCertificate certificate) throws InvalidCertificateException {
@objc public func validate(serverCertificate: SMKServerCertificate) throws {
@objc public func throwswrapped_validate(serverCertificate: SMKServerCertificate) throws {
// try {
// if (!Curve.verifySignature(trustRoot, certificate.getCertificate(), certificate.getSignature())) {
// throw new InvalidCertificateException("Signature failed");
@ -84,13 +84,13 @@ public enum SMKCertificateError: Error {
let certificateData = try certificateBuilder.build().serializedData()
// let certificateData = try serverCertificate.toProto().certificate
guard Ed25519.verifySignature(serverCertificate.signatureData,
publicKey: trustRoot.keyData,
data: certificateData) else {
let error = SMKCertificateError.invalidCertificate(description: "Server certificate signature verification failed.")
Logger.error("\(error)")
throw error
}
guard try Ed25519.verifySignature(serverCertificate.signatureData,
publicKey: trustRoot.keyData,
data: certificateData) else {
let error = SMKCertificateError.invalidCertificate(description: "Server certificate signature verification failed.")
Logger.error("\(error)")
throw error
}
// if (REVOKED.contains(certificate.getKeyId())) {
// throw new InvalidCertificateException("Server certificate has been revoked");
// }

85
SignalMetadataKit/src/SMKSecretSessionCipher.swift
View File

@ -127,11 +127,11 @@ public class SMKDecryptResult: NSObject {
// public byte[] encrypt(SignalProtocolAddress destinationAddress, SenderCertificate senderCertificate, byte[]
// paddedPlaintext)
@objc
public func encryptMessage(recipientId: String,
deviceId: Int32,
paddedPlaintext: Data,
senderCertificate: SMKSenderCertificate,
protocolContext: Any?) throws -> Data {
public func throwswrapped_encryptMessage(recipientId: String,
deviceId: Int32,
paddedPlaintext: Data,
senderCertificate: SMKSenderCertificate,
protocolContext: Any?) throws -> Data {
guard recipientId.count > 0 else {
throw SMKError.assertionError(description: "\(SMKSecretSessionCipher.logTag) invalid recipientId")
}
@ -148,8 +148,7 @@ public class SMKDecryptResult: NSObject {
deviceId: deviceId)
// CiphertextMessage message = new SessionCipher(signalProtocolStore, destinationAddress).encrypt(paddedPlaintext);
let encryptedMessage = cipher.encryptMessage(paddedPlaintext,
protocolContext: protocolContext)
let encryptedMessage = try cipher.encryptMessage(paddedPlaintext, protocolContext: protocolContext)
guard let encryptedMessageData = encryptedMessage.serialized() else {
throw SMKError.assertionError(description: "\(logTag) Could not serialize encrypted message.")
@ -183,9 +182,9 @@ public class SMKDecryptResult: NSObject {
])
// EphemeralKeys ephemeralKeys = calculateEphemeralKeys(theirIdentity, ephemeral.getPrivateKey(), ephemeralSalt);
let ephemeralKeys = try calculateEphemeralKeys(ephemeralPublicKey: theirIdentityKey,
ephemeralPrivateKey: ephemeral.ecPrivateKey(),
salt: ephemeralSalt)
let ephemeralKeys = try throwswrapped_calculateEphemeralKeys(ephemeralPublicKey: theirIdentityKey,
ephemeralPrivateKey: ephemeral.ecPrivateKey(),
salt: ephemeralSalt)
// byte[] staticKeyCiphertext = encrypt(ephemeralKeys.cipherKey, ephemeralKeys.macKey,
// ourIdentity.getPublicKey().getPublicKey().serialize());
@ -200,9 +199,9 @@ public class SMKDecryptResult: NSObject {
])
// StaticKeys staticKeys = calculateStaticKeys(theirIdentity, ourIdentity.getPrivateKey(), staticSalt);
let staticKeys = try calculateStaticKeys(staticPublicKey: theirIdentityKey,
staticPrivateKey: ourIdentityKeyPair.ecPrivateKey(),
salt: staticSalt)
let staticKeys = try throwswrapped_calculateStaticKeys(staticPublicKey: theirIdentityKey,
staticPrivateKey: ourIdentityKeyPair.ecPrivateKey(),
salt: staticSalt)
// UnidentifiedSenderMessageContent content = new UnidentifiedSenderMessageContent(message.getType(),
// senderCertificate, message.serialize());
@ -239,12 +238,12 @@ public class SMKDecryptResult: NSObject {
// ProtocolInvalidVersionException, ProtocolDuplicateMessageException,
// ProtocolInvalidKeyIdException, ProtocolUntrustedIdentityException
@objc
public func decryptMessage(certificateValidator: SMKCertificateValidator,
cipherTextData: Data,
timestamp: UInt64,
localRecipientId: String,
localDeviceId: Int32,
protocolContext: Any?) throws -> SMKDecryptResult {
public func throwswrapped_decryptMessage(certificateValidator: SMKCertificateValidator,
cipherTextData: Data,
timestamp: UInt64,
localRecipientId: String,
localDeviceId: Int32,
protocolContext: Any?) throws -> SMKDecryptResult {
guard timestamp > 0 else {
throw SMKError.assertionError(description: "\(logTag) invalid timestamp")
@ -271,9 +270,9 @@ public class SMKDecryptResult: NSObject {
// EphemeralKeys ephemeralKeys = calculateEphemeralKeys(wrapper.getEphemeral(), ourIdentity.getPrivateKey(),
// ephemeralSalt);
let ephemeralKeys = try calculateEphemeralKeys(ephemeralPublicKey: wrapper.ephemeralKey,
ephemeralPrivateKey: ourIdentityKeyPair.ecPrivateKey(),
salt: ephemeralSalt)
let ephemeralKeys = try throwswrapped_calculateEphemeralKeys(ephemeralPublicKey: wrapper.ephemeralKey,
ephemeralPrivateKey: ourIdentityKeyPair.ecPrivateKey(),
salt: ephemeralSalt)
// byte[] staticKeyBytes = decrypt(ephemeralKeys.cipherKey, ephemeralKeys.macKey, wrapper.getEncryptedStatic());
let staticKeyBytes = try decrypt(cipherKey: ephemeralKeys.cipherKey,
@ -290,9 +289,9 @@ public class SMKDecryptResult: NSObject {
])
// StaticKeys staticKeys = calculateStaticKeys(staticKey, ourIdentity.getPrivateKey(), staticSalt);
let staticKeys = try calculateStaticKeys(staticPublicKey: staticKey,
staticPrivateKey: ourIdentityKeyPair.ecPrivateKey(),
salt: staticSalt)
let staticKeys = try throwswrapped_calculateStaticKeys(staticPublicKey: staticKey,
staticPrivateKey: ourIdentityKeyPair.ecPrivateKey(),
salt: staticSalt)
// byte[] messageBytes = decrypt(staticKeys.cipherKey, staticKeys.macKey, wrapper.getEncryptedMessage());
let messageBytes = try decrypt(cipherKey: staticKeys.cipherKey,
@ -309,8 +308,8 @@ public class SMKDecryptResult: NSObject {
}
// validator.validate(content.getSenderCertificate(), timestamp);
try certificateValidator.validate(senderCertificate: messageContent.senderCertificate,
validationTime: timestamp)
try certificateValidator.throwswrapped_validate(senderCertificate: messageContent.senderCertificate,
validationTime: timestamp)
// if (!MessageDigest.isEqual(content.getSenderCertificate().getKey().serialize(), staticKeyBytes)) {
// throw new InvalidKeyException("Sender's certificate key does not match key used in message");
@ -321,7 +320,7 @@ public class SMKDecryptResult: NSObject {
throw SMKError.assertionError(description: "\(logTag) Sender's certificate key does not match key used in message.")
}
let paddedMessagePlaintext = try decrypt(messageContent: messageContent, protocolContext: protocolContext)
let paddedMessagePlaintext = try throwswrapped_decrypt(messageContent: messageContent, protocolContext: protocolContext)
// return new Pair<>(new SignalProtocolAddress(content.getSenderCertificate().getSender(),
// content.getSenderCertificate().getSenderDeviceId()),
@ -343,9 +342,9 @@ public class SMKDecryptResult: NSObject {
// private EphemeralKeys calculateEphemeralKeys(ECPublicKey ephemeralPublic, ECPrivateKey ephemeralPrivate, byte[] salt)
// throws InvalidKeyException {
private func calculateEphemeralKeys(ephemeralPublicKey: ECPublicKey,
ephemeralPrivateKey: ECPrivateKey,
salt: Data) throws -> SMKEphemeralKeys {
private func throwswrapped_calculateEphemeralKeys(ephemeralPublicKey: ECPublicKey,
ephemeralPrivateKey: ECPrivateKey,
salt: Data) throws -> SMKEphemeralKeys {
guard ephemeralPublicKey.keyData.count > 0 else {
throw SMKError.assertionError(description: "\(logTag) invalid ephemeralPublicKey")
}
@ -360,12 +359,12 @@ public class SMKDecryptResult: NSObject {
//
// See:
// https://github.com/signalapp/libsignal-protocol-java/blob/master/java/src/main/java/org/whispersystems/libsignal/ecc/Curve.java#L30
let ephemeralSecret = Curve25519.generateSharedSecret(fromPublicKey: ephemeralPublicKey.keyData, privateKey: ephemeralPrivateKey.keyData)
let ephemeralSecret = try Curve25519.generateSharedSecret(fromPublicKey: ephemeralPublicKey.keyData, privateKey: ephemeralPrivateKey.keyData)
// byte[] ephemeralDerived = new HKDFv3().deriveSecrets(ephemeralSecret, salt, new byte[0], 96);
let kEphemeralDerivedLength: UInt = 96
let ephemeralDerived: Data =
HKDFKit.deriveKey(ephemeralSecret, info: Data(), salt: salt, outputSize: Int32(kEphemeralDerivedLength))
try HKDFKit.deriveKey(ephemeralSecret, info: Data(), salt: salt, outputSize: Int32(kEphemeralDerivedLength))
guard ephemeralDerived.count == kEphemeralDerivedLength else {
throw SMKError.assertionError(description: "\(logTag) derived ephemeral has unexpected length: \(ephemeralDerived.count).")
}
@ -383,9 +382,9 @@ public class SMKDecryptResult: NSObject {
// private StaticKeys calculateStaticKeys(ECPublicKey staticPublic, ECPrivateKey staticPrivate, byte[] salt) throws
// InvalidKeyException {
private func calculateStaticKeys(staticPublicKey: ECPublicKey,
staticPrivateKey: ECPrivateKey,
salt: Data) throws -> SMKStaticKeys {
private func throwswrapped_calculateStaticKeys(staticPublicKey: ECPublicKey,
staticPrivateKey: ECPrivateKey,
salt: Data) throws -> SMKStaticKeys {
guard staticPublicKey.keyData.count > 0 else {
throw SMKError.assertionError(description: "\(logTag) invalid staticPublicKey")
}
@ -400,12 +399,12 @@ public class SMKDecryptResult: NSObject {
//
// See:
// https://github.com/signalapp/libsignal-protocol-java/blob/master/java/src/main/java/org/whispersystems/libsignal/ecc/Curve.java#L30
let staticSecret = Curve25519.generateSharedSecret(fromPublicKey: staticPublicKey.keyData, privateKey: staticPrivateKey.keyData)
let staticSecret = try Curve25519.generateSharedSecret(fromPublicKey: staticPublicKey.keyData, privateKey: staticPrivateKey.keyData)
// byte[] staticDerived = new HKDFv3().deriveSecrets(staticSecret, salt, new byte[0], 96);
let kStaticDerivedLength: UInt = 96
let staticDerived: Data =
HKDFKit.deriveKey(staticSecret, info: Data(), salt: salt, outputSize: Int32(kStaticDerivedLength))
try HKDFKit.deriveKey(staticSecret, info: Data(), salt: salt, outputSize: Int32(kStaticDerivedLength))
guard staticDerived.count == kStaticDerivedLength else {
throw SMKError.assertionError(description: "\(logTag) could not derive static.")
}
@ -466,8 +465,8 @@ public class SMKDecryptResult: NSObject {
// private byte[] decrypt(UnidentifiedSenderMessageContent message)
// throws InvalidVersionException, InvalidMessageException, InvalidKeyException, DuplicateMessageException,
// InvalidKeyIdException, UntrustedIdentityException, LegacyMessageException, NoSessionException
private func decrypt(messageContent: SMKUnidentifiedSenderMessageContent,
protocolContext: Any?) throws -> Data {
private func throwswrapped_decrypt(messageContent: SMKUnidentifiedSenderMessageContent,
protocolContext: Any?) throws -> Data {
// SignalProtocolAddress sender = new SignalProtocolAddress(message.getSenderCertificate().getSender(),
// message.getSenderCertificate().getSenderDeviceId());
@ -488,9 +487,9 @@ public class SMKDecryptResult: NSObject {
var cipherMessage: CipherMessage
switch (messageContent.messageType) {
case .whisper:
cipherMessage = WhisperMessage(data: messageContent.contentData)
cipherMessage = try WhisperMessage(data: messageContent.contentData)
case .prekey:
cipherMessage = PreKeyWhisperMessage(data: messageContent.contentData)
cipherMessage = try PreKeyWhisperMessage(data: messageContent.contentData)
}
let cipher = SessionCipher(sessionStore: sessionStore,
@ -500,7 +499,7 @@ public class SMKDecryptResult: NSObject {
recipientId: senderRecipientId,
deviceId: Int32(senderDeviceId))
let plaintextData = cipher.decrypt(cipherMessage, protocolContext: protocolContext)
let plaintextData = try cipher.decrypt(cipherMessage, protocolContext: protocolContext)
return plaintextData
}

6
SignalMetadataKitTests/src/Data+SMKTests.swift
View File

@ -5,11 +5,11 @@
import Foundation
extension Data {
public var prependKeyType: Data {
public func prependKeyType() -> Data {
return (self as NSData).prependKeyType() as Data
}
public var removeKeyType: Data {
return (self as NSData).removeKeyType() as Data
public func removeKeyType() throws -> Data {
return try (self as NSData).removeKeyType() as Data
}
}

18
SignalMetadataKitTests/src/SMKMiscTest.swift
View File

@ -138,7 +138,7 @@ class SMKTest: XCTestCase {
identityKey: try! bobMockClient.identityKeyPair.ecPublicKey().serialized)!
let aliceToBobSessionBuilder = aliceMockClient.createSessionBuilder(forRecipient: bobMockClient)
aliceToBobSessionBuilder.processPrekeyBundle(bobPreKeyBundle, protocolContext: nil)
try! aliceToBobSessionBuilder.processPrekeyBundle(bobPreKeyBundle, protocolContext: nil)
let aliceToBobCipher = try! aliceMockClient.createSecretSessionCipher()
@ -153,17 +153,19 @@ class SMKTest: XCTestCase {
senderRecipientId: aliceMockClient.recipientId,
expirationTimestamp: 789,
signatureData: Randomness.generateRandomBytes(100)!)
let encryptedMessage = try! aliceToBobCipher.encryptMessage(recipientId: bobMockClient.recipientId,
deviceId: bobMockClient.deviceId,
paddedPlaintext: paddedPlaintext, senderCertificate: senderCertificate, protocolContext: nil)
let encryptedMessage = try! aliceToBobCipher.throwswrapped_encryptMessage(recipientId: bobMockClient.recipientId,
deviceId: bobMockClient.deviceId,
paddedPlaintext: paddedPlaintext, senderCertificate: senderCertificate, protocolContext: nil)
let messageTimestamp = NSDate.ows_millisecondTimeStamp()
let bobToAliceCipher = try! bobMockClient.createSecretSessionCipher()
let decryptedMessage = try! bobToAliceCipher.decryptMessage(certificateValidator: certificateValidator, cipherTextData: encryptedMessage, timestamp: messageTimestamp,
localRecipientId: bobMockClient.recipientId,
localDeviceId: bobMockClient.deviceId,
protocolContext: nil)
let decryptedMessage = try! bobToAliceCipher.throwswrapped_decryptMessage(certificateValidator: certificateValidator,
cipherTextData: encryptedMessage,
timestamp: messageTimestamp,
localRecipientId: bobMockClient.recipientId,
localDeviceId: bobMockClient.deviceId,
protocolContext: nil)
let payload = (decryptedMessage.paddedPayload as NSData).removePadding()
XCTAssertEqual(aliceMockClient.recipientId, decryptedMessage.senderRecipientId)

98
SignalMetadataKitTests/src/SMKSecretSessionCipherTest.swift
View File

@ -48,23 +48,23 @@ class SMKSecretSessionCipherTest: XCTestCase {
// senderCertificate, "smert za smert".getBytes());
// NOTE: The java tests don't bother padding the plaintext.
let alicePlaintext = "smert za smert".data(using: String.Encoding.utf8)!
let ciphertext = try! aliceCipher.encryptMessage(recipientId: bobMockClient.recipientId,
deviceId: bobMockClient.deviceId,
paddedPlaintext: alicePlaintext,
senderCertificate: senderCertificate,
protocolContext: nil)
let ciphertext = try! aliceCipher.throwswrapped_encryptMessage(recipientId: bobMockClient.recipientId,
deviceId: bobMockClient.deviceId,
paddedPlaintext: alicePlaintext,
senderCertificate: senderCertificate,
protocolContext: nil)
// SecretSessionCipher bobCipher = new SecretSessionCipher(bobStore);
let bobCipher: SMKSecretSessionCipher = try! bobMockClient.createSecretSessionCipher()
// Pair<SignalProtocolAddress, byte[]> plaintext = bobCipher.decrypt(new CertificateValidator(trustRoot.getPublicKey()), ciphertext, 31335);
let certificateValidator = SMKCertificateDefaultValidator(trustRoot: try! trustRoot.ecPublicKey())
let bobPlaintext = try! bobCipher.decryptMessage(certificateValidator: certificateValidator,
cipherTextData: ciphertext,
timestamp: 31335,
localRecipientId: bobMockClient.recipientId,
localDeviceId: bobMockClient.deviceId,
protocolContext: nil)
let bobPlaintext = try! bobCipher.throwswrapped_decryptMessage(certificateValidator: certificateValidator,
cipherTextData: ciphertext,
timestamp: 31335,
localRecipientId: bobMockClient.recipientId,
localDeviceId: bobMockClient.deviceId,
protocolContext: nil)
// assertEquals(new String(plaintext.second()), "smert za smert");
XCTAssertEqual(bobPlaintext.paddedPayload, alicePlaintext)
@ -104,11 +104,11 @@ class SMKSecretSessionCipherTest: XCTestCase {
// senderCertificate, "и вот я".getBytes());
// NOTE: The java tests don't bother padding the plaintext.
let alicePlaintext = "и вот я".data(using: String.Encoding.utf8)!
let ciphertext = try! aliceCipher.encryptMessage(recipientId: bobMockClient.recipientId,
deviceId: bobMockClient.deviceId,
paddedPlaintext: alicePlaintext,
senderCertificate: senderCertificate,
protocolContext: nil)
let ciphertext = try! aliceCipher.throwswrapped_encryptMessage(recipientId: bobMockClient.recipientId,
deviceId: bobMockClient.deviceId,
paddedPlaintext: alicePlaintext,
senderCertificate: senderCertificate,
protocolContext: nil)
// SecretSessionCipher bobCipher = new SecretSessionCipher(bobStore);
let bobCipher: SMKSecretSessionCipher = try! bobMockClient.createSecretSessionCipher()
@ -121,12 +121,12 @@ class SMKSecretSessionCipherTest: XCTestCase {
// }
let certificateValidator = SMKCertificateDefaultValidator(trustRoot: try! trustRoot.ecPublicKey())
do {
try bobCipher.decryptMessage(certificateValidator: certificateValidator,
cipherTextData: ciphertext,
timestamp: 31335,
localRecipientId: bobMockClient.recipientId,
localDeviceId: bobMockClient.deviceId,
protocolContext: nil)
_ = try bobCipher.throwswrapped_decryptMessage(certificateValidator: certificateValidator,
cipherTextData: ciphertext,
timestamp: 31335,
localRecipientId: bobMockClient.recipientId,
localDeviceId: bobMockClient.deviceId,
protocolContext: nil)
XCTFail("Decryption should have failed.")
} catch _ as SMKCertificateError {
// Decryption is expected to fail.
@ -163,11 +163,11 @@ class SMKSecretSessionCipherTest: XCTestCase {
// senderCertificate, "и вот я".getBytes());
// NOTE: The java tests don't bother padding the plaintext.
let alicePlaintext = "и вот я".data(using: String.Encoding.utf8)!
let ciphertext = try! aliceCipher.encryptMessage(recipientId: bobMockClient.recipientId,
deviceId: bobMockClient.deviceId,
paddedPlaintext: alicePlaintext,
senderCertificate: senderCertificate,
protocolContext: nil)
let ciphertext = try! aliceCipher.throwswrapped_encryptMessage(recipientId: bobMockClient.recipientId,
deviceId: bobMockClient.deviceId,
paddedPlaintext: alicePlaintext,
senderCertificate: senderCertificate,
protocolContext: nil)
// SecretSessionCipher bobCipher = new SecretSessionCipher(bobStore);
let bobCipher: SMKSecretSessionCipher = try! bobMockClient.createSecretSessionCipher()
@ -180,12 +180,12 @@ class SMKSecretSessionCipherTest: XCTestCase {
// }
let certificateValidator = SMKCertificateDefaultValidator(trustRoot: try! trustRoot.ecPublicKey())
do {
try bobCipher.decryptMessage(certificateValidator: certificateValidator,
cipherTextData: ciphertext,
timestamp: 31338,
localRecipientId: bobMockClient.recipientId,
localDeviceId: bobMockClient.deviceId,
protocolContext: nil)
_ = try bobCipher.throwswrapped_decryptMessage(certificateValidator: certificateValidator,
cipherTextData: ciphertext,
timestamp: 31338,
localRecipientId: bobMockClient.recipientId,
localDeviceId: bobMockClient.deviceId,
protocolContext: nil)
XCTFail("Decryption should have failed.")
} catch _ as SMKCertificateError {
// Decryption is expected to fail.
@ -224,11 +224,11 @@ class SMKSecretSessionCipherTest: XCTestCase {
// senderCertificate, "smert za smert".getBytes());
// NOTE: The java tests don't bother padding the plaintext.
let alicePlaintext = "smert za smert".data(using: String.Encoding.utf8)!
let ciphertext = try! aliceCipher.encryptMessage(recipientId: bobMockClient.recipientId,
deviceId: bobMockClient.deviceId,
paddedPlaintext: alicePlaintext,
senderCertificate: senderCertificate,
protocolContext: nil)
let ciphertext = try! aliceCipher.throwswrapped_encryptMessage(recipientId: bobMockClient.recipientId,
deviceId: bobMockClient.deviceId,
paddedPlaintext: alicePlaintext,
senderCertificate: senderCertificate,
protocolContext: nil)
// SecretSessionCipher bobCipher = new SecretSessionCipher(bobStore);
let bobCipher: SMKSecretSessionCipher = try! bobMockClient.createSecretSessionCipher()
@ -240,12 +240,12 @@ class SMKSecretSessionCipherTest: XCTestCase {
// }
let certificateValidator = SMKCertificateDefaultValidator(trustRoot: try! trustRoot.ecPublicKey())
do {
try bobCipher.decryptMessage(certificateValidator: certificateValidator,
cipherTextData: ciphertext,
timestamp: 31335,
localRecipientId: bobMockClient.recipientId,
localDeviceId: bobMockClient.deviceId,
protocolContext: nil)
try bobCipher.throwswrapped_decryptMessage(certificateValidator: certificateValidator,
cipherTextData: ciphertext,
timestamp: 31335,
localRecipientId: bobMockClient.recipientId,
localDeviceId: bobMockClient.deviceId,
protocolContext: nil)
XCTFail("Decryption should have failed.")
} catch {
// Decryption is expected to fail.
@ -276,7 +276,7 @@ class SMKSecretSessionCipherTest: XCTestCase {
let unsignedServerCertificateData = try! unsignedServerCertificateBuilder.build().serializedData()
// byte[] serverCertificateSignature = Curve.calculateSignature(trustRoot.getPrivateKey(), serverCertificateBytes);
let serverCertificateSignature = Ed25519.sign(unsignedServerCertificateData, with: trustRoot)!
let serverCertificateSignature = try! Ed25519.sign(unsignedServerCertificateData, with: trustRoot)
// ServerCertificate serverCertificate = new ServerCertificate(SignalProtos.ServerCertificate.newBuilder()
// .setCertificate(ByteString.copyFrom(serverCertificateBytes))
@ -305,7 +305,7 @@ class SMKSecretSessionCipherTest: XCTestCase {
let unsignedSenderCertificateData = try! unsignedSenderCertificateBuilder.build().serializedData()
// byte[] senderCertificateSignature = Curve.calculateSignature(serverKey.getPrivateKey(), senderCertificateBytes);
let senderCertificateSignature = Ed25519.sign(unsignedSenderCertificateData, with: serverKey)!
let senderCertificateSignature = try! Ed25519.sign(unsignedSenderCertificateData, with: serverKey)
// return new SenderCertificate(SignalProtos.SenderCertificate.newBuilder()
// .setCertificate(ByteString.copyFrom(senderCertificateBytes))
@ -340,15 +340,15 @@ class SMKSecretSessionCipherTest: XCTestCase {
deviceId: bobMockClient.deviceId,
preKeyId: bobPreKey.id,
preKeyPublic: try! bobPreKey.keyPair.ecPublicKey().serialized,
signedPreKeyPublic: try! bobSignedPreKey.keyPair.ecPublicKey().keyData.prependKeyType,
signedPreKeyPublic: try! bobSignedPreKey.keyPair.ecPublicKey().keyData.prependKeyType(),
signedPreKeyId: bobSignedPreKey.id,
signedPreKeySignature: bobSignedPreKey.signature,
identityKey: try! bobIdentityKey.ecPublicKey().keyData.prependKeyType)!
identityKey: try! bobIdentityKey.ecPublicKey().keyData.prependKeyType())!
// SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, new SignalProtocolAddress("+14152222222", 1));
let aliceSessionBuilder = aliceMockClient.createSessionBuilder(forRecipient: bobMockClient)
// aliceSessionBuilder.process(bobBundle);
aliceSessionBuilder.processPrekeyBundle(bobBundle, protocolContext: nil)
try! aliceSessionBuilder.processPrekeyBundle(bobBundle, protocolContext: nil)
// bobStore.storeSignedPreKey(2, bobSignedPreKey);
// bobStore.storePreKey(1, new PreKeyRecord(1, bobPreKey));

14
SignalMetadataKitTests/src/SMKSenderCertificateTest.swift
View File

@ -53,7 +53,7 @@ class SMKSenderCertificateTest: XCTestCase {
let unsignedSenderCertificateData = try! unsignedCertificateBuilder.build().serializedData()
// byte[] certificateSignature = Curve.calculateSignature(serverKey.getPrivateKey(), certificateBytes);
let senderCertificateSignature = Ed25519.sign(unsignedSenderCertificateData, with: serverKey)!
let senderCertificateSignature = try! Ed25519.sign(unsignedSenderCertificateData, with: serverKey)
// SenderCertificate senderCertificate = new SenderCertificate(SignalProtos.SenderCertificate.newBuilder()
// .setCertificate(ByteString.copyFrom(certificateBytes))
@ -69,7 +69,7 @@ class SMKSenderCertificateTest: XCTestCase {
// new CertificateValidator(trustRoot.getPublicKey()).validate(senderCertificate, 31336);
let certificateValidator = try! SMKCertificateDefaultValidator(trustRoot: trustRoot.ecPublicKey())
try! certificateValidator.validate(senderCertificate: signedSenderCertificate, validationTime: 31336)
try! certificateValidator.throwswrapped_validate(senderCertificate: signedSenderCertificate, validationTime: 31336)
}
// public void testExpiredSignature() throws InvalidCertificateException, InvalidKeyException {
@ -100,7 +100,7 @@ class SMKSenderCertificateTest: XCTestCase {
let unsignedSenderCertificateData = try! unsignedCertificateBuilder.build().serializedData()
// byte[] certificateSignature = Curve.calculateSignature(serverKey.getPrivateKey(), certificateBytes);
let senderCertificateSignature = Ed25519.sign(unsignedSenderCertificateData, with: serverKey)!
let senderCertificateSignature = try! Ed25519.sign(unsignedSenderCertificateData, with: serverKey)
// SenderCertificate senderCertificate = new SenderCertificate(SignalProtos.SenderCertificate.newBuilder()
// .setCertificate(ByteString.copyFrom(certificateBytes))
@ -121,7 +121,7 @@ class SMKSenderCertificateTest: XCTestCase {
// // good
// }
let certificateValidator = try! SMKCertificateDefaultValidator(trustRoot: trustRoot.ecPublicKey())
XCTAssertThrowsError(try certificateValidator.validate(senderCertificate: signedSenderCertificate, validationTime: 31338))
XCTAssertThrowsError(try certificateValidator.throwswrapped_validate(senderCertificate: signedSenderCertificate, validationTime: 31338))
}
// public void testBadSignature() throws InvalidCertificateException, InvalidKeyException {
@ -152,7 +152,7 @@ class SMKSenderCertificateTest: XCTestCase {
let unsignedSenderCertificateData = try! unsignedCertificateBuilder.build().serializedData()
// byte[] certificateSignature = Curve.calculateSignature(serverKey.getPrivateKey(), certificateBytes);
let senderCertificateSignature = Ed25519.sign(unsignedSenderCertificateData, with: serverKey)!
let senderCertificateSignature = try! Ed25519.sign(unsignedSenderCertificateData, with: serverKey)
// for (int i=0;i<certificateSignature.length;i++) {
for i in 0..<senderCertificateSignature.count {
@ -186,7 +186,7 @@ class SMKSenderCertificateTest: XCTestCase {
// // good
// }
let certificateValidator = try! SMKCertificateDefaultValidator(trustRoot: trustRoot.ecPublicKey())
XCTAssertThrowsError(try certificateValidator.validate(senderCertificate: signedSenderCertificate, validationTime: 31336))
XCTAssertThrowsError(try certificateValidator.throwswrapped_validate(senderCertificate: signedSenderCertificate, validationTime: 31336))
}
}
}
@ -206,7 +206,7 @@ class SMKSenderCertificateTest: XCTestCase {
let unsignedServerCertificateData = try! unsignedServerCertificateBuilder.build().serializedData()
// byte[] certificateSignature = Curve.calculateSignature(trustRoot.getPrivateKey(), certificateBytes);
let serverCertificateSignature = Ed25519.sign(unsignedServerCertificateData, with: trustRoot)!
let serverCertificateSignature = try! Ed25519.sign(unsignedServerCertificateData, with: trustRoot)
// return SignalProtos.ServerCertificate.newBuilder()
// .setCertificate(ByteString.copyFrom(certificateBytes))

10
SignalMetadataKitTests/src/SMKServerCertificateTest.swift
View File

@ -72,7 +72,7 @@ class SMKServerCertificateTest: XCTestCase {
let unsignedServerCertificateData = try! unsignedServerCertificateBuilder.build().serializedData()
// byte[] certificateSignature = Curve.calculateSignature(trustRoot.getPrivateKey(), certificateBytes);
let serverCertificateSignature = Ed25519.sign(unsignedServerCertificateData, with: trustRoot)!
let serverCertificateSignature = try! Ed25519.sign(unsignedServerCertificateData, with: trustRoot)
// byte[] serialized = SignalProtos.ServerCertificate.newBuilder()
// .setCertificate(ByteString.copyFrom(certificateBytes))
@ -86,7 +86,7 @@ class SMKServerCertificateTest: XCTestCase {
// new CertificateValidator(trustRoot.getPublicKey()).validate(new ServerCertificate(serialized));
let certificateValidator = SMKCertificateDefaultValidator(trustRoot: try! trustRoot.ecPublicKey())
try! certificateValidator.validate(serverCertificate: parsed)
try! certificateValidator.throwswrapped_validate(serverCertificate: parsed)
}
// public void testBadSignature() throws Exception {
@ -108,7 +108,7 @@ class SMKServerCertificateTest: XCTestCase {
let unsignedServerCertificateData = try! unsignedServerCertificateBuilder.build().serializedData()
// byte[] certificateSignature = Curve.calculateSignature(trustRoot.getPrivateKey(), certificateBytes);
let serverCertificateSignature = Ed25519.sign(unsignedServerCertificateData, with: trustRoot)!
let serverCertificateSignature = try! Ed25519.sign(unsignedServerCertificateData, with: trustRoot)
// for (int i=0;i<certificateSignature.length;i++) {
for i in 0..<serverCertificateSignature.count {
@ -140,7 +140,7 @@ class SMKServerCertificateTest: XCTestCase {
// // good
// }
let certificateValidator = SMKCertificateDefaultValidator(trustRoot: try! trustRoot.ecPublicKey())
XCTAssertThrowsError(try certificateValidator.validate(serverCertificate: parsed))
XCTAssertThrowsError(try certificateValidator.throwswrapped_validate(serverCertificate: parsed))
}
}
@ -192,7 +192,7 @@ class SMKServerCertificateTest: XCTestCase {
// }
// }
let certificateValidator = SMKCertificateDefaultValidator(trustRoot: try! trustRoot.ecPublicKey())
XCTAssertThrowsError(try certificateValidator.validate(serverCertificate: parsed))
XCTAssertThrowsError(try certificateValidator.throwswrapped_validate(serverCertificate: parsed))
}
}
}

32
SignalMetadataKitTests/src/SMKSessionCipherTest.swift
View File

@ -107,19 +107,19 @@ class SMKSessionCipherTest: XCTestCase {
// }
for _ in 1...2010 {
let plaintext = "you've never been so hungry, you've never been so cold".data(using: String.Encoding.utf8)!
let message = aliceCipher.encryptMessage(plaintext, protocolContext: nil)
let message = try! aliceCipher.encryptMessage(plaintext, protocolContext: nil)
inflight.append(message)
}
// bobCipher.decrypt(new SignalMessage(inflight.get(1000).serialize()));
// bobCipher.decrypt(new SignalMessage(inflight.get(inflight.size()-1).serialize()));
let midpointMessage = bobCipher.decrypt(inflight[1000], protocolContext: nil)
let midpointMessage = try! bobCipher.decrypt(inflight[1000], protocolContext: nil)
XCTAssertNotNil(midpointMessage)
let lastMessage = bobCipher.decrypt(inflight.last!, protocolContext: nil)
let lastMessage = try! bobCipher.decrypt(inflight.last!, protocolContext: nil)
XCTAssertNotNil(lastMessage)
// TODO: Why isn't this failing?
let firstMessage = bobCipher.decrypt(inflight[0], protocolContext: nil)
let firstMessage = try! bobCipher.decrypt(inflight[0], protocolContext: nil)
XCTAssertNotNil(firstMessage)
// try {
// bobCipher.decrypt(new SignalMessage(inflight.get(0).serialize()));
@ -155,9 +155,9 @@ class SMKSessionCipherTest: XCTestCase {
// TODO: Why isn't the java test padding the plaintext?
let alicePaddedPlaintext = (alicePlaintext as NSData).paddedMessageBody()!
// CiphertextMessage message = aliceCipher.encrypt(alicePlaintext);
let message = aliceCipher.encryptMessage(alicePaddedPlaintext, protocolContext: nil)
let message = try! aliceCipher.encryptMessage(alicePaddedPlaintext, protocolContext: nil)
// byte[] bobPlaintext = bobCipher.decrypt(new SignalMessage(message.serialize()));
let bobPaddedPlaintext = bobCipher.decrypt(message, protocolContext: nil)
let bobPaddedPlaintext = try! bobCipher.decrypt(message, protocolContext: nil)
let bobPlaintext = (bobPaddedPlaintext as NSData).removePadding()
// assertTrue(Arrays.equals(alicePlaintext, bobPlaintext));
@ -167,9 +167,9 @@ class SMKSessionCipherTest: XCTestCase {
let bobReply = "This is a message from Bob.".data(using: String.Encoding.utf8)!
let bobReplyPadded = (bobReply as NSData).paddedMessageBody()!
// CiphertextMessage reply = bobCipher.encrypt(bobReply);
let reply = bobCipher.encryptMessage(bobReplyPadded, protocolContext: nil)
let reply = try! bobCipher.encryptMessage(bobReplyPadded, protocolContext: nil)
// byte[] receivedReply = aliceCipher.decrypt(new SignalMessage(reply.serialize()));
let receivedReplyPadded = aliceCipher.decrypt(reply, protocolContext: nil)
let receivedReplyPadded = try! aliceCipher.decrypt(reply, protocolContext: nil)
let receivedReply = (receivedReplyPadded as NSData).removePadding()
// assertTrue(Arrays.equals(bobReply, receivedReply));
@ -185,7 +185,7 @@ class SMKSessionCipherTest: XCTestCase {
// aliceCiphertextMessages.add(aliceCipher.encrypt(("смерть за смерть " + i).getBytes()));
for i in 1...50 {
let plaintext = "смерть за смерть \(i)".data(using: String.Encoding.utf8)!
let message = aliceCipher.encryptMessage(plaintext, protocolContext: nil)
let message = try! aliceCipher.encryptMessage(plaintext, protocolContext: nil)
aliceMessages.append((plaintext:plaintext, message:message))
}
@ -203,7 +203,7 @@ class SMKSessionCipherTest: XCTestCase {
let aliceMessagesLeft = aliceMessages[0 ..< alicePivot]
let aliceMessagesRight = aliceMessages[alicePivot ..< aliceMessages.count]
for (plaintext, message) in aliceMessagesLeft {
let receivedPlaintext = bobCipher.decrypt(message, protocolContext: nil)
let receivedPlaintext = try! bobCipher.decrypt(message, protocolContext: nil)
XCTAssertEqual(plaintext, receivedPlaintext)
}
@ -217,7 +217,7 @@ class SMKSessionCipherTest: XCTestCase {
// }
for i in 1...20 {
let plaintext = "смерть за смерть \(i)".data(using: String.Encoding.utf8)!
let message = bobCipher.encryptMessage(plaintext, protocolContext: nil)
let message = try! bobCipher.encryptMessage(plaintext, protocolContext: nil)
bobMessages.append((plaintext:plaintext, message:message))
}
@ -235,7 +235,7 @@ class SMKSessionCipherTest: XCTestCase {
let bobMessagesLeft = bobMessages[0 ..< bobPivot]
let bobMessagesRight = bobMessages[bobPivot ..< bobMessages.count]
for (plaintext, message) in bobMessagesLeft {
let receivedPlaintext = aliceCipher.decrypt(message, protocolContext: nil)
let receivedPlaintext = try! aliceCipher.decrypt(message, protocolContext: nil)
XCTAssertEqual(plaintext, receivedPlaintext)
}
@ -244,7 +244,7 @@ class SMKSessionCipherTest: XCTestCase {
// assertTrue(Arrays.equals(receivedPlaintext, alicePlaintextMessages.get(i)));
// }
for (plaintext, message) in aliceMessagesRight {
let receivedPlaintext = bobCipher.decrypt(message, protocolContext: nil)
let receivedPlaintext = try! bobCipher.decrypt(message, protocolContext: nil)
XCTAssertEqual(plaintext, receivedPlaintext)
}
//
@ -253,7 +253,7 @@ class SMKSessionCipherTest: XCTestCase {
// assertTrue(Arrays.equals(receivedPlaintext, bobPlaintextMessages.get(i)));
// }
for (plaintext, message) in bobMessagesRight {
let receivedPlaintext = aliceCipher.decrypt(message, protocolContext: nil)
let receivedPlaintext = try! aliceCipher.decrypt(message, protocolContext: nil)
XCTAssertEqual(plaintext, receivedPlaintext)
}
}
@ -325,9 +325,9 @@ class SMKSessionCipherTest: XCTestCase {
// TODO: We could expose this constant in SessionBuilder.h.
let currentVersion: Int32 = 3
// RatchetingSession.initializeSession(aliceSessionState, aliceParameters);
RatchetingSession.initializeSession(aliceSessionState, sessionVersion: currentVersion, aliceParameters: aliceParameters)
try! RatchetingSession.initializeSession(aliceSessionState, sessionVersion: currentVersion, aliceParameters: aliceParameters)
// RatchetingSession.initializeSession(bobSessionState, bobParameters);
RatchetingSession.initializeSession(bobSessionState, sessionVersion: currentVersion, bobParameters: bobParameters)
try! RatchetingSession.initializeSession(bobSessionState, sessionVersion: currentVersion, bobParameters: bobParameters)
}
}

6
SignalMetadataKitTests/src/SMKTestUtils.swift
View File

@ -7,11 +7,11 @@ import SignalMetadataKit
class MockCertificateValidator: NSObject, SMKCertificateValidator {
@objc public func validate(senderCertificate: SMKSenderCertificate, validationTime: UInt64) throws {
@objc public func throwswrapped_validate(senderCertificate: SMKSenderCertificate, validationTime: UInt64) throws {
// Do not throw
}
@objc public func validate(serverCertificate: SMKServerCertificate) throws {
@objc public func throwswrapped_validate(serverCertificate: SMKServerCertificate) throws {
// Do not throw
}
}
@ -170,7 +170,7 @@ class MockSignedPreKeyStore: NSObject, SignedPreKeyStore {
let signedPreKeyId: Int32 = Int32(arc4random_uniform(UInt32(INT32_MAX)))
let keyPair = Curve25519.generateKeyPair()
let generatedAt = Date()
let signature = Ed25519.sign((keyPair.publicKey as NSData).prependKeyType() as Data, with: identityKeyPair)
let signature = try! Ed25519.sign((keyPair.publicKey as NSData).prependKeyType() as Data, with: identityKeyPair)
let signedPreKey = SignedPreKeyRecord(id: signedPreKeyId, keyPair: keyPair, signature: signature, generatedAt: generatedAt)!
keyMap[signedPreKeyId] = signedPreKey
return signedPreKey