380 lines
19 KiB
C++
380 lines
19 KiB
C++
#include "util.h"
|
|
#include <sodium/crypto_sign.h>
|
|
#include <string>
|
|
|
|
namespace util {
|
|
|
|
std::mutex util_mutex_ = std::mutex();
|
|
|
|
jbyteArray bytes_from_ustring(JNIEnv* env, session::ustring_view from_str) {
|
|
size_t length = from_str.length();
|
|
auto jlength = (jsize)length;
|
|
jbyteArray new_array = env->NewByteArray(jlength);
|
|
env->SetByteArrayRegion(new_array, 0, jlength, (jbyte*)from_str.data());
|
|
return new_array;
|
|
}
|
|
|
|
session::ustring ustring_from_bytes(JNIEnv* env, jbyteArray byteArray) {
|
|
size_t len = env->GetArrayLength(byteArray);
|
|
auto bytes = env->GetByteArrayElements(byteArray, nullptr);
|
|
|
|
session::ustring st{reinterpret_cast<const unsigned char *>(bytes), len};
|
|
env->ReleaseByteArrayElements(byteArray, bytes, 0);
|
|
return st;
|
|
}
|
|
|
|
session::ustring ustring_from_jstring(JNIEnv* env, jstring string) {
|
|
size_t len = env->GetStringUTFLength(string);
|
|
auto chars = env->GetStringUTFChars(string, nullptr);
|
|
|
|
session::ustring st{reinterpret_cast<const unsigned char *>(chars), len};
|
|
env->ReleaseStringUTFChars(string, chars);
|
|
return st;
|
|
}
|
|
|
|
jobject serialize_user_pic(JNIEnv *env, session::config::profile_pic pic) {
|
|
jclass returnObjectClass = env->FindClass("network/loki/messenger/libsession_util/util/UserPic");
|
|
jmethodID constructor = env->GetMethodID(returnObjectClass, "<init>", "(Ljava/lang/String;[B)V");
|
|
jstring url = env->NewStringUTF(pic.url.data());
|
|
jbyteArray byteArray = util::bytes_from_ustring(env, pic.key);
|
|
return env->NewObject(returnObjectClass, constructor, url, byteArray);
|
|
}
|
|
|
|
std::pair<jstring, jbyteArray> deserialize_user_pic(JNIEnv *env, jobject user_pic) {
|
|
jclass userPicClass = env->FindClass("network/loki/messenger/libsession_util/util/UserPic");
|
|
jfieldID picField = env->GetFieldID(userPicClass, "url", "Ljava/lang/String;");
|
|
jfieldID keyField = env->GetFieldID(userPicClass, "key", "[B");
|
|
auto pic = (jstring)env->GetObjectField(user_pic, picField);
|
|
auto key = (jbyteArray)env->GetObjectField(user_pic, keyField);
|
|
return {pic, key};
|
|
}
|
|
|
|
jobject serialize_base_community(JNIEnv *env, const session::config::community& community) {
|
|
jclass base_community_clazz = env->FindClass("network/loki/messenger/libsession_util/util/BaseCommunityInfo");
|
|
jmethodID base_community_constructor = env->GetMethodID(base_community_clazz, "<init>", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
|
|
auto base_url = env->NewStringUTF(community.base_url().data());
|
|
auto room = env->NewStringUTF(community.room().data());
|
|
auto pubkey_jstring = env->NewStringUTF(community.pubkey_hex().data());
|
|
jobject ret = env->NewObject(base_community_clazz, base_community_constructor, base_url, room, pubkey_jstring);
|
|
return ret;
|
|
}
|
|
|
|
session::config::community deserialize_base_community(JNIEnv *env, jobject base_community) {
|
|
jclass base_community_clazz = env->FindClass("network/loki/messenger/libsession_util/util/BaseCommunityInfo");
|
|
jfieldID base_url_field = env->GetFieldID(base_community_clazz, "baseUrl", "Ljava/lang/String;");
|
|
jfieldID room_field = env->GetFieldID(base_community_clazz, "room", "Ljava/lang/String;");
|
|
jfieldID pubkey_hex_field = env->GetFieldID(base_community_clazz, "pubKeyHex", "Ljava/lang/String;");
|
|
auto base_url = (jstring)env->GetObjectField(base_community,base_url_field);
|
|
auto room = (jstring)env->GetObjectField(base_community, room_field);
|
|
auto pub_key_hex = (jstring)env->GetObjectField(base_community, pubkey_hex_field);
|
|
auto base_url_chars = env->GetStringUTFChars(base_url, nullptr);
|
|
auto room_chars = env->GetStringUTFChars(room, nullptr);
|
|
auto pub_key_hex_chars = env->GetStringUTFChars(pub_key_hex, nullptr);
|
|
|
|
auto community = session::config::community(base_url_chars, room_chars, pub_key_hex_chars);
|
|
|
|
env->ReleaseStringUTFChars(base_url, base_url_chars);
|
|
env->ReleaseStringUTFChars(room, room_chars);
|
|
env->ReleaseStringUTFChars(pub_key_hex, pub_key_hex_chars);
|
|
return community;
|
|
}
|
|
|
|
jobject serialize_expiry(JNIEnv *env, const session::config::expiration_mode& mode, const std::chrono::seconds& time_seconds) {
|
|
jclass none = env->FindClass("network/loki/messenger/libsession_util/util/ExpiryMode$NONE");
|
|
jfieldID none_instance = env->GetStaticFieldID(none, "INSTANCE", "Lnetwork/loki/messenger/libsession_util/util/ExpiryMode$NONE;");
|
|
jclass after_send = env->FindClass("network/loki/messenger/libsession_util/util/ExpiryMode$AfterSend");
|
|
jmethodID send_init = env->GetMethodID(after_send, "<init>", "(J)V");
|
|
jclass after_read = env->FindClass("network/loki/messenger/libsession_util/util/ExpiryMode$AfterRead");
|
|
jmethodID read_init = env->GetMethodID(after_read, "<init>", "(J)V");
|
|
|
|
if (mode == session::config::expiration_mode::none) {
|
|
return env->GetStaticObjectField(none, none_instance);
|
|
} else if (mode == session::config::expiration_mode::after_send) {
|
|
return env->NewObject(after_send, send_init, time_seconds.count());
|
|
} else if (mode == session::config::expiration_mode::after_read) {
|
|
return env->NewObject(after_read, read_init, time_seconds.count());
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
std::pair<session::config::expiration_mode, long> deserialize_expiry(JNIEnv *env, jobject expiry_mode) {
|
|
jclass parent = env->FindClass("network/loki/messenger/libsession_util/util/ExpiryMode");
|
|
jclass after_read = env->FindClass("network/loki/messenger/libsession_util/util/ExpiryMode$AfterRead");
|
|
jclass after_send = env->FindClass("network/loki/messenger/libsession_util/util/ExpiryMode$AfterSend");
|
|
jfieldID duration_seconds = env->GetFieldID(parent, "expirySeconds", "J");
|
|
|
|
jclass object_class = env->GetObjectClass(expiry_mode);
|
|
|
|
if (object_class == after_read) {
|
|
return std::pair(session::config::expiration_mode::after_read, env->GetLongField(expiry_mode, duration_seconds));
|
|
} else if (object_class == after_send) {
|
|
return std::pair(session::config::expiration_mode::after_send, env->GetLongField(expiry_mode, duration_seconds));
|
|
}
|
|
return std::pair(session::config::expiration_mode::none, 0);
|
|
}
|
|
|
|
jobject serialize_group_member(JNIEnv* env, const session::config::groups::member& member) {
|
|
jclass group_member_class = env->FindClass("network/loki/messenger/libsession_util/util/GroupMember");
|
|
jmethodID constructor = env->GetMethodID(group_member_class, "<init>", "(Ljava/lang/String;Ljava/lang/String;Lnetwork/loki/messenger/libsession_util/util/UserPic;ZZZZZ)V");
|
|
jobject user_pic = serialize_user_pic(env, member.profile_picture);
|
|
jstring session_id = env->NewStringUTF(member.session_id.data());
|
|
jstring name = env->NewStringUTF(member.name.data());
|
|
jboolean invite_failed = member.invite_failed();
|
|
jboolean invite_pending = member.invite_pending();
|
|
jboolean admin = member.admin;
|
|
jboolean promotion_failed = member.promotion_failed();
|
|
jboolean promotion_pending = member.promotion_pending();
|
|
return env->NewObject(group_member_class,
|
|
constructor,
|
|
session_id,
|
|
name,
|
|
user_pic,
|
|
invite_failed,
|
|
invite_pending,
|
|
admin,
|
|
promotion_failed,
|
|
promotion_pending);
|
|
}
|
|
|
|
session::config::groups::member deserialize_group_member(JNIEnv* env, jobject member) {
|
|
jclass group_member_class = env->FindClass("network/loki/messenger/libsession_util/util/GroupMember");
|
|
jfieldID session_id_field = env->GetFieldID(group_member_class, "sessionId", "Ljava/lang/String;");
|
|
jfieldID name_field = env->GetFieldID(group_member_class, "name", "Ljava/lang/String;");
|
|
jfieldID user_pic_field = env->GetFieldID(group_member_class,"profilePicture", "Lnetwork/loki/messenger/libsession_util/util/UserPic;");
|
|
jfieldID invite_failed_field = env->GetFieldID(group_member_class, "inviteFailed", "Z");
|
|
jfieldID invite_pending_field = env->GetFieldID(group_member_class, "invitePending", "Z");
|
|
jfieldID admin_field = env->GetFieldID(group_member_class, "admin", "Z");
|
|
jfieldID promotion_failed_field = env->GetFieldID(group_member_class, "promotionFailed", "Z");
|
|
jfieldID promotion_pending_field = env->GetFieldID(group_member_class, "promotionPending", "Z");
|
|
auto session_id = (jstring)env->GetObjectField(member, session_id_field);
|
|
auto session_id_bytes = env->GetStringUTFChars(session_id, nullptr);
|
|
auto name = (jstring)env->GetObjectField(member, name_field);
|
|
auto name_bytes = env->GetStringUTFChars(name, nullptr);
|
|
auto user_pic_jobject = env->GetObjectField(member, user_pic_field);
|
|
auto user_pic = deserialize_user_pic(env, user_pic_jobject);
|
|
auto url_bytes = env->GetStringUTFChars(user_pic.first, nullptr);
|
|
auto pic_key = ustring_from_bytes(env, user_pic.second);
|
|
auto invite_failed = env->GetBooleanField(member, invite_failed_field);
|
|
auto invite_pending = env->GetBooleanField(member, invite_pending_field);
|
|
auto admin = env->GetBooleanField(member, admin_field);
|
|
auto promotion_failed = env->GetBooleanField(member, promotion_failed_field);
|
|
auto promotion_pending = env->GetBooleanField(member, promotion_pending_field);
|
|
|
|
// set up the object
|
|
session::config::groups::member group_member(session_id_bytes);
|
|
group_member.name = name_bytes;
|
|
group_member.profile_picture.url = url_bytes;
|
|
group_member.profile_picture.set_key(pic_key);
|
|
|
|
if (invite_pending) {
|
|
group_member.set_invited(false);
|
|
} else if (invite_failed) {
|
|
group_member.set_invited(true);
|
|
}
|
|
|
|
if (promotion_pending) {
|
|
group_member.set_promoted(false);
|
|
} else if (promotion_failed) {
|
|
group_member.set_promoted(true);
|
|
}
|
|
|
|
group_member.admin = admin;
|
|
|
|
env->ReleaseStringUTFChars(user_pic.first, url_bytes);
|
|
env->ReleaseStringUTFChars(session_id, session_id_bytes);
|
|
env->ReleaseStringUTFChars(name, name_bytes);
|
|
return group_member;
|
|
}
|
|
|
|
jobject build_string_stack(JNIEnv* env, std::vector<std::string> to_add) {
|
|
jclass stack_class = env->FindClass("java/util/Stack");
|
|
jmethodID constructor = env->GetMethodID(stack_class,"<init>", "()V");
|
|
jmethodID add = env->GetMethodID(stack_class, "push", "(Ljava/lang/Object;)Ljava/lang/Object;");
|
|
jobject our_stack = env->NewObject(stack_class, constructor);
|
|
for (std::basic_string_view<char> string: to_add) {
|
|
env->CallObjectMethod(our_stack, add, env->NewStringUTF(string.data()));
|
|
}
|
|
return our_stack;
|
|
}
|
|
|
|
jobject deserialize_swarm_auth(JNIEnv *env, session::config::groups::Keys::swarm_auth auth) {
|
|
jclass swarm_auth_class = env->FindClass("network/loki/messenger/libsession_util/GroupKeysConfig$SwarmAuth");
|
|
jmethodID constructor = env->GetMethodID(swarm_auth_class, "<init>", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
|
|
jstring sub_account = env->NewStringUTF(auth.subaccount.data());
|
|
jstring sub_account_sig = env->NewStringUTF(auth.subaccount_sig.data());
|
|
jstring signature = env->NewStringUTF(auth.signature.data());
|
|
|
|
return env->NewObject(swarm_auth_class, constructor, sub_account, sub_account_sig, signature);
|
|
}
|
|
|
|
jobject jlongFromOptional(JNIEnv* env, std::optional<long long> optional) {
|
|
if (!optional) {
|
|
return nullptr;
|
|
}
|
|
jclass longClass = env->FindClass("java/lang/Long");
|
|
jmethodID constructor = env->GetMethodID(longClass, "<init>", "(J)V");
|
|
jobject returned = env->NewObject(longClass, constructor, (jlong)*optional);
|
|
return returned;
|
|
}
|
|
|
|
jstring jstringFromOptional(JNIEnv* env, std::optional<std::string_view> optional) {
|
|
if (!optional) {
|
|
return nullptr;
|
|
}
|
|
return env->NewStringUTF(optional->data());
|
|
}
|
|
|
|
jobject serialize_session_id(JNIEnv* env, std::string_view session_id) {
|
|
if (session_id.size() != 66) return nullptr;
|
|
|
|
jclass id_class = env->FindClass("org/session/libsignal/utilities/SessionId");
|
|
jmethodID session_id_constructor = env->GetStaticMethodID(id_class, "from", "(Ljava/lang/String;)Lorg/session/libsignal/utilities/SessionId;");
|
|
|
|
jstring session_id_string = env->NewStringUTF(session_id.data());
|
|
|
|
return env->CallStaticObjectMethod(id_class, session_id_constructor, session_id_string);
|
|
}
|
|
|
|
std::string deserialize_session_id(JNIEnv* env, jobject session_id) {
|
|
jclass session_id_class = env->FindClass("org/session/libsignal/utilities/SessionId");
|
|
jmethodID get_string = env->GetMethodID(session_id_class, "hexString", "()Ljava/lang/String;");
|
|
auto hex_jstring = (jstring)env->CallObjectMethod(session_id, get_string);
|
|
auto hex_bytes = env->GetStringUTFChars(hex_jstring, nullptr);
|
|
std::string hex_string{hex_bytes};
|
|
env->ReleaseStringUTFChars(hex_jstring, hex_bytes);
|
|
return hex_string;
|
|
}
|
|
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jobject JNICALL
|
|
Java_network_loki_messenger_libsession_1util_util_Sodium_ed25519KeyPair(JNIEnv *env, jobject thiz, jbyteArray seed) {
|
|
std::array<unsigned char, 32> ed_pk; // NOLINT(cppcoreguidelines-pro-type-member-init)
|
|
std::array<unsigned char, 64> ed_sk; // NOLINT(cppcoreguidelines-pro-type-member-init)
|
|
auto seed_bytes = util::ustring_from_bytes(env, seed);
|
|
crypto_sign_ed25519_seed_keypair(ed_pk.data(), ed_sk.data(), seed_bytes.data());
|
|
|
|
jclass kp_class = env->FindClass("network/loki/messenger/libsession_util/util/KeyPair");
|
|
jmethodID kp_constructor = env->GetMethodID(kp_class, "<init>", "([B[B)V");
|
|
|
|
jbyteArray pk_jarray = util::bytes_from_ustring(env, session::ustring_view {ed_pk.data(), ed_pk.size()});
|
|
jbyteArray sk_jarray = util::bytes_from_ustring(env, session::ustring_view {ed_sk.data(), ed_sk.size()});
|
|
|
|
jobject return_obj = env->NewObject(kp_class, kp_constructor, pk_jarray, sk_jarray);
|
|
return return_obj;
|
|
}
|
|
extern "C"
|
|
JNIEXPORT jbyteArray JNICALL
|
|
Java_network_loki_messenger_libsession_1util_util_Sodium_ed25519PkToCurve25519(JNIEnv *env,
|
|
jobject thiz,
|
|
jbyteArray pk) {
|
|
auto ed_pk = util::ustring_from_bytes(env, pk);
|
|
std::array<unsigned char, 32> curve_pk; // NOLINT(cppcoreguidelines-pro-type-member-init)
|
|
int success = crypto_sign_ed25519_pk_to_curve25519(curve_pk.data(), ed_pk.data());
|
|
if (success != 0) {
|
|
jclass exception = env->FindClass("java/lang/Exception");
|
|
env->ThrowNew(exception, "Invalid crypto_sign_ed25519_pk_to_curve25519 operation");
|
|
return nullptr;
|
|
}
|
|
jbyteArray curve_pk_jarray = util::bytes_from_ustring(env, session::ustring_view {curve_pk.data(), curve_pk.size()});
|
|
return curve_pk_jarray;
|
|
}
|
|
extern "C"
|
|
JNIEXPORT jobject JNICALL
|
|
Java_network_loki_messenger_libsession_1util_util_BaseCommunityInfo_00024Companion_parseFullUrl(
|
|
JNIEnv *env, jobject thiz, jstring full_url) {
|
|
auto bytes = env->GetStringUTFChars(full_url, nullptr);
|
|
auto [base, room, pk] = session::config::community::parse_full_url(bytes);
|
|
env->ReleaseStringUTFChars(full_url, bytes);
|
|
|
|
jclass clazz = env->FindClass("kotlin/Triple");
|
|
jmethodID constructor = env->GetMethodID(clazz, "<init>", "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V");
|
|
|
|
auto base_j = env->NewStringUTF(base.data());
|
|
auto room_j = env->NewStringUTF(room.data());
|
|
auto pk_jbytes = util::bytes_from_ustring(env, pk);
|
|
|
|
jobject triple = env->NewObject(clazz, constructor, base_j, room_j, pk_jbytes);
|
|
return triple;
|
|
}
|
|
extern "C"
|
|
JNIEXPORT jstring JNICALL
|
|
Java_network_loki_messenger_libsession_1util_util_BaseCommunityInfo_fullUrl(JNIEnv *env,
|
|
jobject thiz) {
|
|
auto deserialized = util::deserialize_base_community(env, thiz);
|
|
auto full_url = deserialized.full_url();
|
|
return env->NewStringUTF(full_url.data());
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jint JNICALL
|
|
Java_org_session_libsignal_utilities_Namespace_DEFAULT(JNIEnv *env, jobject thiz) {
|
|
return 0;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jint JNICALL
|
|
Java_org_session_libsignal_utilities_Namespace_USER_1PROFILE(JNIEnv *env, jobject thiz) {
|
|
return (int) session::config::Namespace::UserProfile;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jint JNICALL
|
|
Java_org_session_libsignal_utilities_Namespace_CONTACTS(JNIEnv *env, jobject thiz) {
|
|
return (int) session::config::Namespace::Contacts;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jint JNICALL
|
|
Java_org_session_libsignal_utilities_Namespace_CONVO_1INFO_1VOLATILE(JNIEnv *env, jobject thiz) {
|
|
return (int) session::config::Namespace::ConvoInfoVolatile;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jint JNICALL
|
|
Java_org_session_libsignal_utilities_Namespace_GROUPS(JNIEnv *env, jobject thiz) {
|
|
return (int) session::config::Namespace::UserGroups;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jint JNICALL
|
|
Java_org_session_libsignal_utilities_Namespace_CLOSED_1GROUP_1INFO(JNIEnv *env, jobject thiz) {
|
|
return (int) session::config::Namespace::GroupInfo;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jint JNICALL
|
|
Java_org_session_libsignal_utilities_Namespace_CLOSED_1GROUP_1MEMBERS(JNIEnv *env, jobject thiz) {
|
|
return (int) session::config::Namespace::GroupMembers;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jint JNICALL
|
|
Java_org_session_libsignal_utilities_Namespace_ENCRYPTION_1KEYS(JNIEnv *env, jobject thiz) {
|
|
return (int) session::config::Namespace::GroupKeys;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jint JNICALL
|
|
Java_org_session_libsignal_utilities_Namespace_CLOSED_1GROUP_1MESSAGES(JNIEnv *env, jobject thiz) {
|
|
return (int) session::config::Namespace::GroupMessages;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT void JNICALL
|
|
Java_network_loki_messenger_libsession_1util_Config_free(JNIEnv *env, jobject thiz) {
|
|
jclass baseClass = env->FindClass("network/loki/messenger/libsession_util/Config");
|
|
jfieldID pointerField = env->GetFieldID(baseClass, "pointer", "J");
|
|
jclass sig = env->FindClass("network/loki/messenger/libsession_util/ConfigSig");
|
|
jclass base = env->FindClass("network/loki/messenger/libsession_util/ConfigBase");
|
|
jclass ours = env->GetObjectClass(thiz);
|
|
if (env->IsSameObject(sig, ours)) {
|
|
// config sig object
|
|
auto config = (session::config::ConfigSig*) env->GetLongField(thiz, pointerField);
|
|
delete config;
|
|
} else if (env->IsSameObject(base, ours)) {
|
|
auto config = (session::config::ConfigBase*) env->GetLongField(thiz, pointerField);
|
|
delete config;
|
|
}
|
|
} |