mirror/libsignal
0
0
Fork 0
mirror of https://github.com/signalapp/libsignal.git synced 2024-09-20 20:03:07 +02:00
Code

We need 2 ctx pointers

Browse Source 
The first in the store to act as a "self" and the second for the user context
This commit is contained in:
Jack Lloyd 2020-09-25 16:12:29 -04:00
parent 1eee61bf44
commit b59af68f9b
2 changed files with 66 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
signal_ffi.h
View File

@ -72,26 +72,28 @@ typedef struct SignalMessage SignalMessage;
typedef struct SignedPreKeyRecord SignedPreKeyRecord;
typedef int (*LoadSession)(SessionRecord**, const ProtocolAddress*, void*);
typedef int (*LoadSession)(void*, SessionRecord**, const ProtocolAddress*, void*);
typedef int (*StoreSession)(const ProtocolAddress*, const SessionRecord*, void*);
typedef int (*StoreSession)(void*, const ProtocolAddress*, const SessionRecord*, void*);
typedef struct {
void *ctx;
LoadSession load_session;
StoreSession store_session;
} FfiSessionStoreStruct;
typedef int (*GetIdentityKeyPair)(PrivateKey**, void*);
typedef int (*GetIdentityKeyPair)(void*, PrivateKey**, void*);
typedef int (*GetLocalRegistrationId)(uint32_t*, void*);
typedef int (*GetLocalRegistrationId)(void*, uint32_t*, void*);
typedef int (*SaveIdentityKey)(const ProtocolAddress*, const PublicKey*, void*);
typedef int (*SaveIdentityKey)(void*, const ProtocolAddress*, const PublicKey*, void*);
typedef int (*GetIdentityKey)(PublicKey**, const ProtocolAddress*, void*);
typedef int (*GetIdentityKey)(void*, PublicKey**, const ProtocolAddress*, void*);
typedef int (*IsTrustedIdentity)(const ProtocolAddress*, const PublicKey*, unsigned int, void*);
typedef int (*IsTrustedIdentity)(void*, const ProtocolAddress*, const PublicKey*, unsigned int, void*);
typedef struct {
void *ctx;
GetIdentityKeyPair get_identity_key_pair;
GetLocalRegistrationId get_local_registration_id;
SaveIdentityKey save_identity;
@ -99,36 +101,41 @@ typedef struct {
IsTrustedIdentity is_trusted_identity;
} FfiIdentityKeyStoreStruct;
typedef int (*LoadPreKey)(PreKeyRecord**, uint32_t, void*);
typedef int (*LoadPreKey)(void*, PreKeyRecord**, uint32_t, void*);
typedef int (*StorePreKey)(uint32_t, const PreKeyRecord*, void*);
typedef int (*StorePreKey)(void*, uint32_t, const PreKeyRecord*, void*);
typedef int (*RemovePreKey)(uint32_t, void*);
typedef int (*RemovePreKey)(void*, uint32_t, void*);
typedef struct {
void *ctx;
LoadPreKey load_pre_key;
StorePreKey store_pre_key;
RemovePreKey remove_pre_key;
} FfiPreKeyStoreStruct;
typedef int (*LoadSignedPreKey)(SignedPreKeyRecord**, uint32_t, void*);
typedef int (*LoadSignedPreKey)(void*, SignedPreKeyRecord**, uint32_t, void*);
typedef int (*StoreSignedPreKey)(uint32_t, const SignedPreKeyRecord*, void*);
typedef int (*StoreSignedPreKey)(void*, uint32_t, const SignedPreKeyRecord*, void*);
typedef struct {
void *ctx;
LoadSignedPreKey load_signed_pre_key;
StoreSignedPreKey store_signed_pre_key;
} FfiSignedPreKeyStoreStruct;
typedef int (*LoadSenderKey)(SenderKeyRecord**, const SenderKeyName*, void*);
typedef int (*LoadSenderKey)(void*, SenderKeyRecord**, const SenderKeyName*, void*);
typedef int (*StoreSenderKey)(const SenderKeyName*, const SenderKeyRecord*, void*);
typedef int (*StoreSenderKey)(void*, const SenderKeyName*, const SenderKeyRecord*, void*);
typedef struct {
void *ctx;
LoadSenderKey load_sender_key;
StoreSenderKey store_sender_key;
} FfiSenderKeyStoreStruct;
void signal_print_ptr(const void *p);
void signal_free_string(const char *buf);
void signal_free_buffer(const unsigned char *buf, size_t buf_len);
@ -362,7 +369,8 @@ SignalFfiError *signal_sender_key_message_serialize(const SenderKeyMessage *obj,
const unsigned char **out,
size_t *out_len);
SignalFfiError *signal_sender_key_message_verify_signature(const SenderKeyMessage *skm,
SignalFfiError *signal_sender_key_message_verify_signature(unsigned int *result,
const SenderKeyMessage *skm,
const PublicKey *pubkey);
SignalFfiError *signal_sender_key_distribution_message_new(SenderKeyDistributionMessage **obj,

77
src/lib.rs
View File

@ -10,6 +10,11 @@ mod util;
use crate::util::*;
#[no_mangle]
pub unsafe extern "C" fn signal_print_ptr(p: *const std::ffi::c_void) {
println!("In rust thats {:?}", p);
}
#[no_mangle]
pub unsafe extern "C" fn signal_free_string(buf: *const c_char) {
if buf.is_null() {
@ -515,6 +520,7 @@ ffi_fn_get_bytearray!(signal_sender_key_message_serialize(SenderKeyMessage) usin
#[no_mangle]
pub unsafe extern "C" fn signal_sender_key_message_verify_signature(
result: *mut c_uint,
skm: *const SenderKeyMessage,
pubkey: *const PublicKey,
) -> *mut SignalFfiError {
@ -522,12 +528,10 @@ pub unsafe extern "C" fn signal_sender_key_message_verify_signature(
let skm = native_handle_cast::<SenderKeyMessage>(skm)?;
let pubkey = native_handle_cast::<PublicKey>(pubkey)?;
match skm.verify_signature(pubkey)? {
true => Ok(()),
false => Err(SignalFfiError::Signal(
SignalProtocolError::SignatureValidationFailed,
)),
}
let valid = skm.verify_signature(pubkey)?;
*result = if valid { 1 } else { 0 };
Ok(())
})
}
@ -760,18 +764,19 @@ ffi_fn_deserialize!(signal_sender_key_record_deserialize(SenderKeyRecord) is Sen
ffi_fn_get_bytearray!(signal_sender_key_record_serialize(SenderKeyRecord) using
|sks: &SenderKeyRecord| sks.serialize());
type GetIdentityKeyPair = extern "C" fn(*mut *mut PrivateKey, *mut c_void) -> c_int;
type GetLocalRegistrationId = extern "C" fn(*mut u32, *mut c_void) -> c_int;
type GetIdentityKeyPair = extern "C" fn(*mut c_void, *mut *mut PrivateKey, *mut c_void) -> c_int;
type GetLocalRegistrationId = extern "C" fn(*mut c_void, *mut u32, *mut c_void) -> c_int;
type GetIdentityKey =
extern "C" fn(*mut *mut PublicKey, *const ProtocolAddress, *mut c_void) -> c_int;
extern "C" fn(*mut c_void, *mut *mut PublicKey, *const ProtocolAddress, *mut c_void) -> c_int;
type SaveIdentityKey =
extern "C" fn(*const ProtocolAddress, *const PublicKey, *mut c_void) -> c_int;
extern "C" fn(*mut c_void, *const ProtocolAddress, *const PublicKey, *mut c_void) -> c_int;
type IsTrustedIdentity =
extern "C" fn(*const ProtocolAddress, *const PublicKey, c_uint, *mut c_void) -> c_int;
extern "C" fn(*mut c_void, *const ProtocolAddress, *const PublicKey, c_uint, *mut c_void) -> c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FfiIdentityKeyStoreStruct {
ctx: *mut c_void,
get_identity_key_pair: GetIdentityKeyPair,
get_local_registration_id: GetLocalRegistrationId,
save_identity: SaveIdentityKey,
@ -795,7 +800,7 @@ impl IdentityKeyStore for FfiIdentityKeyStore {
fn get_identity_key_pair(&self, ctx: Context) -> Result<IdentityKeyPair, SignalProtocolError> {
let ctx = ctx.unwrap_or(std::ptr::null_mut());
let mut key = std::ptr::null_mut();
let result = (self.store.get_identity_key_pair)(&mut key, ctx);
let result = (self.store.get_identity_key_pair)(self.store.ctx, &mut key, ctx);
if result != 0 {
return Err(
@ -819,7 +824,7 @@ impl IdentityKeyStore for FfiIdentityKeyStore {
fn get_local_registration_id(&self, ctx: Context) -> Result<u32, SignalProtocolError> {
let ctx = ctx.unwrap_or(std::ptr::null_mut());
let mut id = 0;
let result = (self.store.get_local_registration_id)(&mut id, ctx);
let result = (self.store.get_local_registration_id)(self.store.ctx, &mut id, ctx);
if result != 0 {
return Err(
@ -840,7 +845,7 @@ impl IdentityKeyStore for FfiIdentityKeyStore {
ctx: Context,
) -> Result<bool, SignalProtocolError> {
let ctx = ctx.unwrap_or(std::ptr::null_mut());
let result = (self.store.save_identity)(&*address, &*identity.public_key(), ctx);
let result = (self.store.save_identity)(self.store.ctx, &*address, &*identity.public_key(), ctx);
match result {
0 => Ok(false),
@ -865,7 +870,7 @@ impl IdentityKeyStore for FfiIdentityKeyStore {
1
};
let result =
(self.store.is_trusted_identity)(&*address, &*identity.public_key(), direction, ctx);
(self.store.is_trusted_identity)(self.store.ctx, &*address, &*identity.public_key(), direction, ctx);
match result {
0 => Ok(false),
@ -886,7 +891,7 @@ impl IdentityKeyStore for FfiIdentityKeyStore {
) -> Result<Option<IdentityKey>, SignalProtocolError> {
let ctx = ctx.unwrap_or(std::ptr::null_mut());
let mut key = std::ptr::null_mut();
let result = (self.store.get_identity)(&mut key, &*address, ctx);
let result = (self.store.get_identity)(self.store.ctx, &mut key, &*address, ctx);
if result != 0 {
return Err(
@ -907,13 +912,14 @@ impl IdentityKeyStore for FfiIdentityKeyStore {
}
}
type LoadPreKey = extern "C" fn(*mut *mut PreKeyRecord, u32, *mut c_void) -> c_int;
type StorePreKey = extern "C" fn(u32, *const PreKeyRecord, *mut c_void) -> c_int;
type RemovePreKey = extern "C" fn(u32, *mut c_void) -> c_int;
type LoadPreKey = extern "C" fn(*mut c_void, *mut *mut PreKeyRecord, u32, *mut c_void) -> c_int;
type StorePreKey = extern "C" fn(*mut c_void, u32, *const PreKeyRecord, *mut c_void) -> c_int;
type RemovePreKey = extern "C" fn(*mut c_void, u32, *mut c_void) -> c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FfiPreKeyStoreStruct {
ctx: *mut c_void,
load_pre_key: LoadPreKey,
store_pre_key: StorePreKey,
remove_pre_key: RemovePreKey,
@ -939,7 +945,7 @@ impl PreKeyStore for FfiPreKeyStore {
) -> Result<PreKeyRecord, SignalProtocolError> {
let ctx = ctx.unwrap_or(std::ptr::null_mut());
let mut record = std::ptr::null_mut();
let result = (self.store.load_pre_key)(&mut record, prekey_id, ctx);
let result = (self.store.load_pre_key)(self.store.ctx, &mut record, prekey_id, ctx);
if result != 0 {
return Err(
@ -965,7 +971,7 @@ impl PreKeyStore for FfiPreKeyStore {
ctx: Context,
) -> Result<(), SignalProtocolError> {
let ctx = ctx.unwrap_or(std::ptr::null_mut());
let result = (self.store.store_pre_key)(prekey_id, &*record, ctx);
let result = (self.store.store_pre_key)(self.store.ctx, prekey_id, &*record, ctx);
if result != 0 {
return Err(
@ -981,7 +987,7 @@ impl PreKeyStore for FfiPreKeyStore {
fn remove_pre_key(&mut self, prekey_id: u32, ctx: Context) -> Result<(), SignalProtocolError> {
let ctx = ctx.unwrap_or(std::ptr::null_mut());
let result = (self.store.remove_pre_key)(prekey_id, ctx);
let result = (self.store.remove_pre_key)(self.store.ctx, prekey_id, ctx);
if result != 0 {
return Err(
@ -996,12 +1002,13 @@ impl PreKeyStore for FfiPreKeyStore {
}
}
type LoadSignedPreKey = extern "C" fn(*mut *mut SignedPreKeyRecord, u32, *mut c_void) -> c_int;
type StoreSignedPreKey = extern "C" fn(u32, *const SignedPreKeyRecord, *mut c_void) -> c_int;
type LoadSignedPreKey = extern "C" fn(*mut c_void, *mut *mut SignedPreKeyRecord, u32, *mut c_void) -> c_int;
type StoreSignedPreKey = extern "C" fn(*mut c_void, u32, *const SignedPreKeyRecord, *mut c_void) -> c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FfiSignedPreKeyStoreStruct {
ctx: *mut c_void,
load_signed_pre_key: LoadSignedPreKey,
store_signed_pre_key: StoreSignedPreKey,
}
@ -1026,7 +1033,7 @@ impl SignedPreKeyStore for FfiSignedPreKeyStore {
) -> Result<SignedPreKeyRecord, SignalProtocolError> {
let ctx = ctx.unwrap_or(std::ptr::null_mut());
let mut record = std::ptr::null_mut();
let result = (self.store.load_signed_pre_key)(&mut record, prekey_id, ctx);
let result = (self.store.load_signed_pre_key)(self.store.ctx, &mut record, prekey_id, ctx);
if result != 0 {
return Err(
@ -1052,7 +1059,7 @@ impl SignedPreKeyStore for FfiSignedPreKeyStore {
ctx: Context,
) -> Result<(), SignalProtocolError> {
let ctx = ctx.unwrap_or(std::ptr::null_mut());
let result = (self.store.store_signed_pre_key)(prekey_id, &*record, ctx);
let result = (self.store.store_signed_pre_key)(self.store.ctx, prekey_id, &*record, ctx);
if result != 0 {
return Err(
@ -1068,13 +1075,14 @@ impl SignedPreKeyStore for FfiSignedPreKeyStore {
}
type LoadSession =
extern "C" fn(*mut *mut SessionRecord, *const ProtocolAddress, *mut c_void) -> c_int;
extern "C" fn(*mut c_void, *mut *mut SessionRecord, *const ProtocolAddress, *mut c_void) -> c_int;
type StoreSession =
extern "C" fn(*const ProtocolAddress, *const SessionRecord, *mut c_void) -> c_int;
extern "C" fn(*mut c_void, *const ProtocolAddress, *const SessionRecord, *mut c_void) -> c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FfiSessionStoreStruct {
ctx: *mut c_void,
load_session: LoadSession,
store_session: StoreSession,
}
@ -1099,7 +1107,7 @@ impl SessionStore for FfiSessionStore {
) -> Result<Option<SessionRecord>, SignalProtocolError> {
let ctx = ctx.unwrap_or(std::ptr::null_mut());
let mut record = std::ptr::null_mut();
let result = (self.store.load_session)(&mut record, &*address, ctx);
let result = (self.store.load_session)(self.store.ctx, &mut record, &*address, ctx);
if result != 0 {
return Err(
@ -1120,7 +1128,7 @@ impl SessionStore for FfiSessionStore {
ctx: Context,
) -> Result<(), SignalProtocolError> {
let ctx = ctx.unwrap_or(std::ptr::null_mut());
let result = (self.store.store_session)(&*address, &*record, ctx);
let result = (self.store.store_session)(self.store.ctx, &*address, &*record, ctx);
if result != 0 {
return Err(
@ -1271,13 +1279,14 @@ pub unsafe extern "C" fn signal_decrypt_pre_key_message(
}
type LoadSenderKey =
extern "C" fn(*mut *mut SenderKeyRecord, *const SenderKeyName, *mut c_void) -> c_int;
extern "C" fn(*mut c_void, *mut *mut SenderKeyRecord, *const SenderKeyName, *mut c_void) -> c_int;
type StoreSenderKey =
extern "C" fn(*const SenderKeyName, *const SenderKeyRecord, *mut c_void) -> c_int;
extern "C" fn(*mut c_void, *const SenderKeyName, *const SenderKeyRecord, *mut c_void) -> c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FfiSenderKeyStoreStruct {
ctx: *mut c_void,
load_sender_key: LoadSenderKey,
store_sender_key: StoreSenderKey,
}
@ -1302,7 +1311,7 @@ impl SenderKeyStore for FfiSenderKeyStore {
ctx: Context,
) -> Result<(), SignalProtocolError> {
let ctx = ctx.unwrap_or(std::ptr::null_mut());
let result = (self.store.store_sender_key)(&*sender_key_name, &*record, ctx);
let result = (self.store.store_sender_key)(self.store.ctx, &*sender_key_name, &*record, ctx);
if result != 0 {
return Err(
@ -1323,7 +1332,7 @@ impl SenderKeyStore for FfiSenderKeyStore {
) -> Result<Option<SenderKeyRecord>, SignalProtocolError> {
let ctx = ctx.unwrap_or(std::ptr::null_mut());
let mut record = std::ptr::null_mut();
let result = (self.store.load_sender_key)(&mut record, &*sender_key_name, ctx);
let result = (self.store.load_sender_key)(self.store.ctx, &mut record, &*sender_key_name, ctx);
if result != 0 {
return Err(