olm_account.cpp 15.8 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*
 * Copyright 2016 OpenMarket Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "olm_account.h"

pedroGitt's avatar
pedroGitt committed
19
20
using namespace AndroidOlmSdk;

21
22
/**
* Init memory allocation for account creation.
23
* @return valid memory allocation, NULL otherwise
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
**/
OlmAccount* initializeAccountMemory()
{
    OlmAccount* accountPtr = NULL;
    size_t accountSize = olm_account_size();

    if(NULL != (accountPtr=(OlmAccount*)malloc(accountSize)))
    { // init account object
      accountPtr = olm_account(accountPtr);
      LOGD("## initializeAccountMemory(): success - OLM account size=%lu",accountSize);
    }
    else
    {
      LOGE("## initializeAccountMemory(): failure - OOM");
    }

    return accountPtr;
}

/**
 * Release the account allocation made by initializeAccountMemory().<br>
 * This method MUST be called when java counter part account instance is done.
 *
 */
pedroGitt's avatar
pedroGitt committed
48
JNIEXPORT void OLM_ACCOUNT_FUNC_DEF(releaseAccountJni)(JNIEnv *env, jobject thiz)
49
50
51
52
53
54
55
56
57
58
{
  OlmAccount* accountPtr = NULL;

  LOGD("## releaseAccountJni(): accountPtr=%p",accountPtr);

  if(NULL == (accountPtr = (OlmAccount*)getAccountInstanceId(env,thiz)))
  {
      LOGE("## releaseAccountJni(): failure - invalid Account ptr=NULL");
  }
  else
pedroGitt's avatar
pedroGitt committed
59
60
61
  {
    olm_clear_account(accountPtr);

62
    LOGD("## releaseAccountJni(): IN");
pedroGitt's avatar
pedroGitt committed
63
    // even if free(NULL) does not crash, logs are performed for debug purpose
64
65
66
67
68
69
70
71
    free(accountPtr);
    LOGD("## releaseAccountJni(): OUT");
  }
}

/**
* Initialize a new account and return it to JAVA side.<br>
* Since a C prt is returned as a jlong, special care will be taken
72
* to make the cast (OlmAccount* => jlong) platform independent.
73
74
* @return the initialized OlmAccount* instance if init succeed, NULL otherwise
**/
pedroGitt's avatar
pedroGitt committed
75
JNIEXPORT jlong OLM_ACCOUNT_FUNC_DEF(initNewAccountJni)(JNIEnv *env, jobject thiz)
76
{
pedroGitt's avatar
pedroGitt committed
77
78
    OlmAccount *accountPtr = NULL;
    uint8_t *randomBuffPtr = NULL;
79
    size_t accountRetCode;
pedroGitt's avatar
pedroGitt committed
80
    size_t randomSize;
81
82
83
84
85
86
87
88

    // init account memory allocation
    if(NULL == (accountPtr = initializeAccountMemory()))
    {
        LOGE("## initNewAccount(): failure - init account OOM");
    }
    else
    {
89
        // get random buffer size
90
        randomSize = olm_create_account_random_length(accountPtr);
91
92
93
94
        LOGD("## initNewAccount(): randomSize=%lu", randomSize);

        // allocate random buffer
        if((0!=randomSize) && !setRandomInBuffer(&randomBuffPtr, randomSize))
95
        {
pedroGitt's avatar
pedroGitt committed
96
            LOGE("## initNewAccount(): failure - random buffer init");
97
98
        }
        else
pedroGitt's avatar
pedroGitt committed
99
        {
100
            // create account
pedroGitt's avatar
pedroGitt committed
101
            accountRetCode = olm_create_account(accountPtr, (void*)randomBuffPtr, randomSize);
102
103
104
105
106
107
108
109
110
111
            if(accountRetCode == olm_error()) {
                const char *errorMsgPtr = olm_account_last_error(accountPtr);
                LOGE("## initNewAccount(): failure - account creation failed Msg=%s", errorMsgPtr);
             }

            LOGD("## initNewAccount(): success - OLM account created");
            LOGD("## initNewAccount(): success - accountPtr=%p (jlong)(intptr_t)accountPtr=%lld",accountPtr,(jlong)(intptr_t)accountPtr);
        }
    }

pedroGitt's avatar
pedroGitt committed
112
113
114
115
116
    if(NULL != randomBuffPtr)
    {
        free(randomBuffPtr);
    }

117
118
119
    return (jlong)(intptr_t)accountPtr;
}

pedroGitt's avatar
pedroGitt committed
120
121


122
123
124
125
126
127
128
129
// *********************************************************************
// ************************* IDENTITY KEYS API *************************
// *********************************************************************
/**
* Get identity keys: Ed25519 fingerprint key and Curve25519 identity key.<br>
* The keys are returned in the byte array.
* @return a valid byte array if operation succeed, null otherwise
**/
pedroGitt's avatar
pedroGitt committed
130
JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(identityKeysJni)(JNIEnv *env, jobject thiz)
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
{
    OlmAccount* accountPtr = NULL;
    size_t identityKeysLength;
    uint8_t *identityKeysBytesPtr;
    size_t keysResult;
    jbyteArray byteArrayRetValue = NULL;

    LOGD("## identityKeys(): accountPtr =%p",accountPtr);

    if(NULL == (accountPtr = (OlmAccount*)getAccountInstanceId(env,thiz)))
    {
        LOGE("## identityKeys(): failure - invalid Account ptr=NULL");
    }
    else
    {   // identity keys allocation
        identityKeysLength = olm_account_identity_keys_length(accountPtr);
147
        if(NULL == (identityKeysBytesPtr=(uint8_t*)malloc(identityKeysLength*sizeof(uint8_t))))
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
        {
            LOGE("## identityKeys(): failure - identity keys array OOM");
        }
        else
        {   // retrieve key pairs in identityKeysBytesPtr
            keysResult = olm_account_identity_keys(accountPtr, identityKeysBytesPtr, identityKeysLength);
            if(keysResult == olm_error()) {
                const char *errorMsgPtr = olm_account_last_error(accountPtr);
                LOGE("## identityKeys(): failure - error getting identity keys Msg=%s",errorMsgPtr);
            }
            else
            {   // allocate the byte array to be returned to java
                if(NULL == (byteArrayRetValue=env->NewByteArray(identityKeysLength)))
                {
                    LOGE("## identityKeys(): failure - return byte array OOM");
                }
                else
                {
                    env->SetByteArrayRegion(byteArrayRetValue, 0/*offset*/, identityKeysLength, (const jbyte*)identityKeysBytesPtr);
                    LOGD("## identityKeys(): success - result=%ld", keysResult);
                }
            }

            free(identityKeysBytesPtr);
        }
    }

    return byteArrayRetValue;
}

// *********************************************************************
// ************************* ONE TIME KEYS API *************************
// *********************************************************************
/**
 * Get the maximum number of "one time keys" the account can store.
 *
**/
pedroGitt's avatar
pedroGitt committed
185
JNIEXPORT jlong OLM_ACCOUNT_FUNC_DEF(maxOneTimeKeys)(JNIEnv *env, jobject thiz)
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
{
    OlmAccount* accountPtr = NULL;
    size_t maxKeys = -1;

    if(NULL == (accountPtr = (OlmAccount*)getAccountInstanceId(env,thiz)))
    {
        LOGE("## maxOneTimeKey(): failure - invalid Account ptr=NULL");
    }
    else
    {
        maxKeys = olm_account_max_number_of_one_time_keys(accountPtr);
    }
    LOGD("## maxOneTimeKey(): Max keys=%ld", maxKeys);

    return (jlong)maxKeys;
}

/**
 * Generate "one time keys".
 * @param aNumberOfKeys number of keys to generate
 * @return ERROR_CODE_OK if operation succeed, ERROR_CODE_KO otherwise
**/
pedroGitt's avatar
pedroGitt committed
208
JNIEXPORT jint OLM_ACCOUNT_FUNC_DEF(generateOneTimeKeys)(JNIEnv *env, jobject thiz, jint aNumberOfKeys)
209
{
pedroGitt's avatar
pedroGitt committed
210
211
    OlmAccount *accountPtr = NULL;
    uint8_t *randomBufferPtr = NULL;
212
    jint retCode = ERROR_CODE_KO;
pedroGitt's avatar
pedroGitt committed
213
    size_t randomLength;
214
215
216
217
218
219
220
221
222
    size_t result;


    if(NULL == (accountPtr = (OlmAccount*)getAccountInstanceId(env,thiz)))
    {
        LOGE("## generateOneTimeKeys(): failure - invalid Account ptr");
    }
    else
    {   // keys memory allocation
223
        randomLength = olm_account_generate_one_time_keys_random_length(accountPtr, (size_t)aNumberOfKeys);
pedroGitt's avatar
pedroGitt committed
224
225
        LOGD("## generateOneTimeKeys(): randomLength=%ld", randomLength);

226
        if((0!=randomLength) && !setRandomInBuffer(&randomBufferPtr, randomLength))
227
        {
pedroGitt's avatar
pedroGitt committed
228
            LOGE("## generateOneTimeKeys(): failure - random buffer init");
229
230
        }
        else
pedroGitt's avatar
pedroGitt committed
231
232
233
234
        {
            LOGD("## generateOneTimeKeys(): accountPtr =%p aNumberOfKeys=%d",accountPtr, aNumberOfKeys);

            // retrieve key pairs in keysBytesPtr
235
            result = olm_account_generate_one_time_keys(accountPtr, (size_t)aNumberOfKeys, (void*)randomBufferPtr, randomLength);
236
237
238
239
240
241
242
243
244
245
246
247
            if(result == olm_error()) {
                const char *errorMsgPtr = olm_account_last_error(accountPtr);
                LOGE("## generateOneTimeKeys(): failure - error generating one time keys Msg=%s",errorMsgPtr);
            }
            else
            {
                retCode = ERROR_CODE_OK;
                LOGD("## generateOneTimeKeys(): success - result=%ld", result);
            }
        }
    }

pedroGitt's avatar
pedroGitt committed
248
249
250
251
252
    if(NULL != randomBufferPtr)
    {
        free(randomBufferPtr);
    }

253
254
255
256
    return retCode;
}

/**
257
 * Get "one time keys".<br>
258
259
260
 * Return the public parts of the unpublished "one time keys" for the account
 * @return a valid byte array if operation succeed, null otherwise
**/
pedroGitt's avatar
pedroGitt committed
261
JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(oneTimeKeysJni)(JNIEnv *env, jobject thiz)
262
263
264
265
266
267
268
{
    OlmAccount* accountPtr = NULL;
    size_t keysLength;
    uint8_t *keysBytesPtr;
    size_t keysResult;
    jbyteArray byteArrayRetValue = NULL;

pedroGitt's avatar
pedroGitt committed
269
    LOGD("## oneTimeKeysJni(): IN");
270
271
272

    if(NULL == (accountPtr = (OlmAccount*)getAccountInstanceId(env,thiz)))
    {
pedroGitt's avatar
pedroGitt committed
273
        LOGE("## oneTimeKeysJni(): failure - invalid Account ptr");
274
275
276
277
278
279
    }
    else
    {   // keys memory allocation
        keysLength = olm_account_one_time_keys_length(accountPtr);
        if(NULL == (keysBytesPtr=(uint8_t *)malloc(keysLength*sizeof(uint8_t))))
        {
pedroGitt's avatar
pedroGitt committed
280
            LOGE("## oneTimeKeysJni(): failure - one time keys array OOM");
281
282
283
284
285
286
        }
        else
        {   // retrieve key pairs in keysBytesPtr
            keysResult = olm_account_one_time_keys(accountPtr, keysBytesPtr, keysLength);
            if(keysResult == olm_error()) {
                const char *errorMsgPtr = olm_account_last_error(accountPtr);
pedroGitt's avatar
pedroGitt committed
287
                LOGE("## oneTimeKeysJni(): failure - error getting one time keys Msg=%s",errorMsgPtr);
288
289
290
291
292
            }
            else
            {   // allocate the byte array to be returned to java
                if(NULL == (byteArrayRetValue=env->NewByteArray(keysLength)))
                {
pedroGitt's avatar
pedroGitt committed
293
                    LOGE("## oneTimeKeysJni(): failure - return byte array OOM");
294
295
296
297
                }
                else
                {
                    env->SetByteArrayRegion(byteArrayRetValue, 0/*offset*/, keysLength, (const jbyte*)keysBytesPtr);
pedroGitt's avatar
pedroGitt committed
298
                    LOGD("## oneTimeKeysJni(): success");
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
                }
            }

            free(keysBytesPtr);
        }
    }

    return byteArrayRetValue;
}

/**
 * Remove the "one time keys"  that the session used from the account.
 * Return the public parts of the unpublished "one time keys" for the account
 * @param aNativeOlmSessionId session instance
 * @return ERROR_CODE_OK if operation succeed, ERROR_CODE_NO_MATCHING_ONE_TIME_KEYS if no matching keys, ERROR_CODE_KO otherwise
**/
315
JNIEXPORT jint OLM_ACCOUNT_FUNC_DEF(removeOneTimeKeysForSessionJni)(JNIEnv *env, jobject thiz, jlong aNativeOlmSessionId)
316
317
318
319
320
321
322
323
{
    jint retCode = ERROR_CODE_KO;
    OlmAccount* accountPtr = NULL;
    OlmSession* sessionPtr = (OlmSession*)aNativeOlmSessionId;
    size_t result;

    if(NULL == sessionPtr)
    {
324
        LOGE("## removeOneTimeKeysForSessionJni(): failure - invalid session ptr");
325
326
327
    }
    else if(NULL == (accountPtr = (OlmAccount*)getAccountInstanceId(env,thiz)))
    {
328
        LOGE("## removeOneTimeKeysForSessionJni(): failure - invalid account ptr");
329
330
331
332
333
334
335
    }
    else
    {
        result = olm_remove_one_time_keys(accountPtr, sessionPtr);
        if(result == olm_error())
        {   // the account doesn't have any matching "one time keys"..
            const char *errorMsgPtr = olm_account_last_error(accountPtr);
336
            LOGW("## removeOneTimeKeysForSessionJni(): failure - removing one time keys Msg=%s",errorMsgPtr);
337
338
339
340
341
342

            retCode = ERROR_CODE_NO_MATCHING_ONE_TIME_KEYS;
        }
        else
        {
            retCode = ERROR_CODE_OK;
343
            LOGD("## removeOneTimeKeysForSessionJni(): success");
344
345
346
347
348
349
350
351
352
353
        }
    }

    return retCode;
}

/**
 * Mark the current set of "one time keys" as being published.
 * @return ERROR_CODE_OK if operation succeed, ERROR_CODE_KO otherwise
**/
354
JNIEXPORT jint OLM_ACCOUNT_FUNC_DEF(markOneTimeKeysAsPublishedJni)(JNIEnv *env, jobject thiz)
355
356
357
358
359
360
361
{
    jint retCode = ERROR_CODE_OK;
    OlmAccount* accountPtr = NULL;
    size_t result;

    if(NULL == (accountPtr = (OlmAccount*)getAccountInstanceId(env,thiz)))
    {
362
        LOGE("## markOneTimeKeysAsPublishedJni(): failure - invalid account ptr");
363
364
365
366
367
368
369
370
        retCode = ERROR_CODE_KO;
    }
    else
    {
        result = olm_account_mark_keys_as_published(accountPtr);
        if(result == olm_error())
        {
            const char *errorMsgPtr = olm_account_last_error(accountPtr);
371
            LOGW("## markOneTimeKeysAsPublishedJni(): failure - Msg=%s",errorMsgPtr);
372
373
374
375
            retCode = ERROR_CODE_KO;
        }
        else
        {
376
            LOGD("## markOneTimeKeysAsPublishedJni(): success - retCode=%ld",result);
377
378
379
380
381
382
383
        }
    }

    return retCode;
}

/**
384
385
 * Sign a message with the ed25519 key (fingerprint) for this account.<br>
 * The signed message is returned by the function.
386
 * @param aMessage message to sign
387
 * @return the signed message, null otherwise
388
**/
389
JNIEXPORT jstring OLM_ACCOUNT_FUNC_DEF(signMessageJni)(JNIEnv *env, jobject thiz, jstring aMessage)
390
391
392
{
    OlmAccount* accountPtr = NULL;
    size_t signatureLength;
393
    void* signedMsgPtr;
394
395
396
397
398
    size_t resultSign;
    jstring signedMsgRetValue = NULL;

    if(NULL == aMessage)
    {
399
        LOGE("## signMessageJni(): failure - invalid aMessage param");
400
401
402
    }
    else if(NULL == (accountPtr = (OlmAccount*)getAccountInstanceId(env,thiz)))
    {
403
        LOGE("## signMessageJni(): failure - invalid account ptr");
404
405
406
407
408
409
410
    }
    else
    {
        // convert message from JAVA to C string
        const char* messageToSign = env->GetStringUTFChars(aMessage, 0);
        if(NULL == messageToSign)
        {
411
            LOGE("## signMessageJni(): failure - message JNI allocation OOM");
412
413
414
415
416
417
418
        }
        else
        {
            int messageLength = env->GetStringUTFLength(aMessage);

            // signature memory allocation
            signatureLength = olm_account_signature_length(accountPtr);
419
            if(NULL == (signedMsgPtr = (void*)malloc(signatureLength*sizeof(uint8_t))))
420
            {
421
                LOGE("## signMessageJni(): failure - signature allocation OOM");
422
423
424
            }
            else
            {   // sign message
425
426
427
428
429
                resultSign = olm_account_sign(accountPtr,
                                             (void*)messageToSign,
                                             (size_t)messageLength,
                                             signedMsgPtr,
                                             signatureLength);
430
431
432
                if(resultSign == olm_error())
                {
                    const char *errorMsgPtr = olm_account_last_error(accountPtr);
433
                    LOGE("## signMessageJni(): failure - error signing message Msg=%s",errorMsgPtr);
434
435
                }
                else
436
437
438
                {
                    // TODO check if signedMsgPtr needs to be null ended: signedMsgPtr[resultSign]='\0'
                    // convert to jstring
439
                    signedMsgRetValue = env->NewStringUTF((const char*)signedMsgPtr); // UTF8
440
                    LOGD("## signMessageJni(): success - retCode=%ld",resultSign);
441
442
                }

443
                free(signedMsgPtr);
444
445
446
447
448
449
450
451
452
453
454
            }

            // release messageToSign
            env->ReleaseStringUTFChars(aMessage, messageToSign);
        }
    }

    return signedMsgRetValue;
}


pedroGitt's avatar
pedroGitt committed
455
JNIEXPORT jstring OLM_MANAGER_FUNC_DEF(getOlmLibVersion)(JNIEnv* env, jobject thiz)
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
{
  uint8_t majorVer=0, minorVer=0, patchVer=0;
  jstring returnValueStr=0;
  char buff[150];

  olm_get_library_version(&majorVer, &minorVer, &patchVer);
  LOGD("## getOlmLibVersion(): Major=%d Minor=%d Patch=%d", majorVer, minorVer, patchVer);

  snprintf(buff, sizeof(buff), " V%d.%d.%d", majorVer, minorVer, patchVer);
  returnValueStr = env->NewStringUTF((const char*)buff);

  return returnValueStr;
}