1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
/*
Jabber Protocol Plugin for Miranda NG
Copyright (c) 2002-04 Santithorn Bunchua
Copyright (c) 2005-12 George Hazan
Copyright (c) 2007 Maxim Mluhov
Copyright (ñ) 2012-17 Miranda NG project
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "stdafx.h"
#include <signal_protocol.h>
namespace omemo {
int random_func(uint8_t *data, size_t len, void * /*user_data*/)
{
Utils_GetRandom(data, len);
return 0;
}
struct hmac_sha256_ctx {
uint8_t *key, *data;
size_t key_len, data_len;
};
int hmac_sha256_init_func(void **hmac_context, const uint8_t *key, size_t key_len, void * /*user_data*/)
{
hmac_sha256_ctx *ctx = (hmac_sha256_ctx*)mir_alloc(sizeof(hmac_sha256_ctx));
ctx->key = (uint8_t*)mir_alloc(key_len);
memcpy(ctx->key, key, key_len);
ctx->key_len = key_len;
*hmac_context = ctx;
return 0;
}
int hmac_sha256_update_func(void *hmac_context, const uint8_t *data, size_t data_len, void * /*user_data*/)
{
hmac_sha256_ctx *ctx = (hmac_sha256_ctx*)hmac_context;
ctx->data = (uint8_t*)mir_alloc(data_len);
memcpy(ctx->data, data, data_len);
ctx->data_len = data_len;
return 0;
}
int hmac_sha256_final_func(void *hmac_context, signal_buffer **output, void * /*user_data*/)
{
hmac_sha256_ctx *ctx = (hmac_sha256_ctx*)hmac_context;
BYTE hashout[MIR_SHA256_HASH_SIZE];
mir_hmac_sha256(hashout, ctx->key, ctx->key_len, ctx->data, ctx->data_len);
signal_buffer *output_buffer = signal_buffer_create(hashout, MIR_SHA256_HASH_SIZE);
*output = output_buffer;
return 0;
}
void hmac_sha256_cleanup_func(void * hmac_context, void * /*user_data*/)
{
hmac_sha256_ctx *ctx = (hmac_sha256_ctx*)hmac_context;
mir_free(ctx->key);
mir_free(ctx->data);
}
mir_cs _signal_cs;
mir_cslockfull signal_mutex(_signal_cs);
void lock(void * /*user_data*/)
{
signal_mutex.lock();
}
void unlock(void * /*user_data*/)
{
signal_mutex.unlock();
}
int init_omemo()
{
signal_mutex.unlock(); //fuck...
signal_context *global_context;
signal_context_create(&global_context, NULL);
signal_crypto_provider provider;
provider.random_func = &random_func;
provider.hmac_sha256_init_func = &hmac_sha256_init_func;
provider.hmac_sha256_update_func = &hmac_sha256_update_func;
provider.hmac_sha256_final_func = &hmac_sha256_final_func;
provider.hmac_sha256_cleanup_func = &hmac_sha256_cleanup_func;
signal_context_set_crypto_provider(global_context, &provider);
signal_context_set_locking_functions(global_context, &lock, &unlock);
return 0;
}
};
|
