Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
matrix-org
Olm
Commits
ea13edca
Commit
ea13edca
authored
Apr 22, 2019
by
Hubert Chathi
Browse files
don't use variable length or zero-length arrays in test files
as some compilers don't handle that
parent
157c0fa6
Changes
9
Expand all
Hide whitespace changes
Inline
Side-by-side
tests/test_base64.cpp
View file @
ea13edca
...
...
@@ -14,7 +14,7 @@ std::size_t input_length = sizeof(input) - 1;
std
::
size_t
output_length
=
olm
::
encode_base64_length
(
input_length
);
assert_equals
(
std
::
size_t
(
15
),
output_length
);
std
::
uint8_t
output
[
output_length
];
std
::
uint8_t
output
[
15
];
olm
::
encode_base64
(
input
,
input_length
,
output
);
assert_equals
(
expected_output
,
output
,
output_length
);
}
...
...
@@ -29,7 +29,7 @@ std::size_t input_length = sizeof(input) - 1;
std
::
size_t
output_length
=
::
_olm_encode_base64_length
(
input_length
);
assert_equals
(
std
::
size_t
(
15
),
output_length
);
std
::
uint8_t
output
[
output_length
];
std
::
uint8_t
output
[
15
];
output_length
=
::
_olm_encode_base64
(
input
,
input_length
,
output
);
assert_equals
(
std
::
size_t
(
15
),
output_length
);
assert_equals
(
expected_output
,
output
,
output_length
);
...
...
@@ -45,7 +45,7 @@ std::size_t input_length = sizeof(input) - 1;
std
::
size_t
output_length
=
olm
::
decode_base64_length
(
input_length
);
assert_equals
(
std
::
size_t
(
11
),
output_length
);
std
::
uint8_t
output
[
output_length
];
std
::
uint8_t
output
[
11
];
olm
::
decode_base64
(
input
,
input_length
,
output
);
assert_equals
(
expected_output
,
output
,
output_length
);
}
...
...
@@ -60,7 +60,7 @@ std::size_t input_length = sizeof(input) - 1;
std
::
size_t
output_length
=
::
_olm_decode_base64_length
(
input_length
);
assert_equals
(
std
::
size_t
(
11
),
output_length
);
std
::
uint8_t
output
[
output_length
];
std
::
uint8_t
output
[
11
];
output_length
=
::
_olm_decode_base64
(
input
,
input_length
,
output
);
assert_equals
(
std
::
size_t
(
11
),
output_length
);
assert_equals
(
expected_output
,
output
,
output_length
);
...
...
tests/test_crypto.cpp
View file @
ea13edca
...
...
@@ -146,7 +146,10 @@ assert_equals(input, actual, length);
TestCase
test_case
(
"SHA 256 Test Case 1"
);
std
::
uint8_t
input
[
0
]
=
{};
// we want to take the hash of the empty string, but MSVC doesn't like
// allocating 0 bytes, so allocate one item, but pass a length of zero to
// sha256
std
::
uint8_t
input
[
1
]
=
{
0
};
std
::
uint8_t
expected
[
32
]
=
{
0xE3
,
0xB0
,
0xC4
,
0x42
,
0x98
,
0xFC
,
0x1C
,
0x14
,
...
...
@@ -157,7 +160,7 @@ std::uint8_t expected[32] = {
std
::
uint8_t
actual
[
32
];
_olm_crypto_sha256
(
input
,
sizeof
(
input
)
,
actual
);
_olm_crypto_sha256
(
input
,
0
,
actual
);
assert_equals
(
expected
,
actual
,
32
);
...
...
@@ -167,7 +170,10 @@ assert_equals(expected, actual, 32);
TestCase
test_case
(
"HMAC Test Case 1"
);
std
::
uint8_t
input
[
0
]
=
{};
// we want to take the hash of the empty string, but MSVC doesn't like
// allocating 0 bytes, so allocate one item, but pass a length of zero to
// hmac_sha256
std
::
uint8_t
input
[
1
]
=
{
0
};
std
::
uint8_t
expected
[
32
]
=
{
0xb6
,
0x13
,
0x67
,
0x9a
,
0x08
,
0x14
,
0xd9
,
0xec
,
...
...
@@ -178,7 +184,7 @@ std::uint8_t expected[32] = {
std
::
uint8_t
actual
[
32
];
_olm_crypto_hmac_sha256
(
input
,
sizeof
(
input
),
input
,
sizeof
(
input
)
,
actual
);
_olm_crypto_hmac_sha256
(
input
,
0
,
input
,
0
,
actual
);
assert_equals
(
expected
,
actual
,
32
);
...
...
tests/test_group_session.cpp
View file @
ea13edca
...
...
@@ -16,6 +16,7 @@
#include
"olm/outbound_group_session.h"
#include
"unittest.hh"
#include
<vector>
int
main
()
{
...
...
@@ -23,33 +24,32 @@ int main() {
TestCase
test_case
(
"Pickle outbound group session"
);
size_t
size
=
olm_outbound_group_session_size
();
uint8_t
memory
[
size
]
;
OlmOutboundGroupSession
*
session
=
olm_outbound_group_session
(
memory
);
std
::
vector
<
uint8_t
>
memory
(
size
)
;
OlmOutboundGroupSession
*
session
=
olm_outbound_group_session
(
memory
.
data
()
);
size_t
pickle_length
=
olm_pickle_outbound_group_session_length
(
session
);
uint8_t
pickle1
[
pickle_length
]
;
std
::
vector
<
uint8_t
>
pickle1
(
pickle_length
)
;
size_t
res
=
olm_pickle_outbound_group_session
(
session
,
"secret_key"
,
10
,
pickle1
,
pickle_length
session
,
"secret_key"
,
10
,
pickle1
.
data
()
,
pickle_length
);
assert_equals
(
pickle_length
,
res
);
uint8_t
pickle2
[
pickle_length
];
memcpy
(
pickle2
,
pickle1
,
pickle_length
);
std
::
vector
<
uint8_t
>
pickle2
(
pickle1
);
uint8_t
buffer2
[
size
]
;
OlmOutboundGroupSession
*
session2
=
olm_outbound_group_session
(
buffer2
);
std
::
vector
<
uint8_t
>
buffer2
(
size
)
;
OlmOutboundGroupSession
*
session2
=
olm_outbound_group_session
(
buffer2
.
data
()
);
res
=
olm_unpickle_outbound_group_session
(
session2
,
"secret_key"
,
10
,
pickle2
,
pickle_length
session2
,
"secret_key"
,
10
,
pickle2
.
data
()
,
pickle_length
);
assert_not_equals
((
size_t
)
-
1
,
res
);
assert_equals
(
pickle_length
,
olm_pickle_outbound_group_session_length
(
session2
));
res
=
olm_pickle_outbound_group_session
(
session2
,
"secret_key"
,
10
,
pickle2
,
pickle_length
session2
,
"secret_key"
,
10
,
pickle2
.
data
()
,
pickle_length
);
assert_equals
(
pickle_length
,
res
);
assert_equals
(
pickle1
,
pickle2
,
pickle_length
);
assert_equals
(
pickle1
.
data
()
,
pickle2
.
data
()
,
pickle_length
);
}
...
...
@@ -57,32 +57,31 @@ int main() {
TestCase
test_case
(
"Pickle inbound group session"
);
size_t
size
=
olm_inbound_group_session_size
();
uint8_t
memory
[
size
]
;
OlmInboundGroupSession
*
session
=
olm_inbound_group_session
(
memory
);
std
::
vector
<
uint8_t
>
memory
(
size
)
;
OlmInboundGroupSession
*
session
=
olm_inbound_group_session
(
memory
.
data
()
);
size_t
pickle_length
=
olm_pickle_inbound_group_session_length
(
session
);
uint8_t
pickle1
[
pickle_length
]
;
std
::
vector
<
uint8_t
>
pickle1
(
pickle_length
)
;
size_t
res
=
olm_pickle_inbound_group_session
(
session
,
"secret_key"
,
10
,
pickle1
,
pickle_length
session
,
"secret_key"
,
10
,
pickle1
.
data
()
,
pickle_length
);
assert_equals
(
pickle_length
,
res
);
uint8_t
pickle2
[
pickle_length
];
memcpy
(
pickle2
,
pickle1
,
pickle_length
);
std
::
vector
<
uint8_t
>
pickle2
(
pickle1
);
uint8_t
buffer2
[
size
]
;
OlmInboundGroupSession
*
session2
=
olm_inbound_group_session
(
buffer2
);
std
::
vector
<
uint8_t
>
buffer2
(
size
)
;
OlmInboundGroupSession
*
session2
=
olm_inbound_group_session
(
buffer2
.
data
()
);
res
=
olm_unpickle_inbound_group_session
(
session2
,
"secret_key"
,
10
,
pickle2
,
pickle_length
session2
,
"secret_key"
,
10
,
pickle2
.
data
()
,
pickle_length
);
assert_not_equals
((
size_t
)
-
1
,
res
);
assert_equals
(
pickle_length
,
olm_pickle_inbound_group_session_length
(
session2
));
res
=
olm_pickle_inbound_group_session
(
session2
,
"secret_key"
,
10
,
pickle2
,
pickle_length
session2
,
"secret_key"
,
10
,
pickle2
.
data
()
,
pickle_length
);
assert_equals
(
pickle1
,
pickle2
,
pickle_length
);
assert_equals
(
pickle1
.
data
()
,
pickle2
.
data
()
,
pickle_length
);
}
{
...
...
@@ -99,8 +98,8 @@ int main() {
/* build the outbound session */
size_t
size
=
olm_outbound_group_session_size
();
uint8_t
memory
[
size
]
;
OlmOutboundGroupSession
*
session
=
olm_outbound_group_session
(
memory
);
std
::
vector
<
uint8_t
>
memory
(
size
)
;
OlmOutboundGroupSession
*
session
=
olm_outbound_group_session
(
memory
.
data
()
);
assert_equals
((
size_t
)
160
,
olm_init_outbound_group_session_random_length
(
session
));
...
...
@@ -111,8 +110,8 @@ int main() {
assert_equals
(
0U
,
olm_outbound_group_session_message_index
(
session
));
size_t
session_key_len
=
olm_outbound_group_session_key_length
(
session
);
uint8_t
session_key
[
session_key_len
]
;
olm_outbound_group_session_key
(
session
,
session_key
,
session_key_len
);
std
::
vector
<
uint8_t
>
session_key
(
session_key_len
)
;
olm_outbound_group_session_key
(
session
,
session_key
.
data
()
,
session_key_len
);
/* encode the message */
uint8_t
plaintext
[]
=
"Message"
;
...
...
@@ -121,57 +120,56 @@ int main() {
size_t
msglen
=
olm_group_encrypt_message_length
(
session
,
plaintext_length
);
uint8_t
msg
[
msglen
]
;
std
::
vector
<
uint8_t
>
msg
(
msglen
)
;
res
=
olm_group_encrypt
(
session
,
plaintext
,
plaintext_length
,
msg
,
msglen
);
msg
.
data
()
,
msglen
);
assert_equals
(
msglen
,
res
);
assert_equals
(
1U
,
olm_outbound_group_session_message_index
(
session
));
/* build the inbound session */
size
=
olm_inbound_group_session_size
();
uint8_t
inbound_session_memory
[
size
]
;
std
::
vector
<
uint8_t
>
inbound_session_memory
(
size
)
;
OlmInboundGroupSession
*
inbound_session
=
olm_inbound_group_session
(
inbound_session_memory
);
olm_inbound_group_session
(
inbound_session_memory
.
data
()
);
assert_equals
(
0
,
olm_inbound_group_session_is_verified
(
inbound_session
));
res
=
olm_init_inbound_group_session
(
inbound_session
,
session_key
,
session_key_len
);
inbound_session
,
session_key
.
data
()
,
session_key_len
);
assert_equals
((
size_t
)
0
,
res
);
assert_equals
(
1
,
olm_inbound_group_session_is_verified
(
inbound_session
));
/* Check the session ids */
size_t
out_session_id_len
=
olm_outbound_group_session_id_length
(
session
);
uint8_t
out_session_id
[
out_session_id_len
]
;
std
::
vector
<
uint8_t
>
out_session_id
(
out_session_id_len
)
;
assert_equals
(
out_session_id_len
,
olm_outbound_group_session_id
(
session
,
out_session_id
,
out_session_id_len
session
,
out_session_id
.
data
()
,
out_session_id_len
));
size_t
in_session_id_len
=
olm_inbound_group_session_id_length
(
inbound_session
);
uint8_t
in_session_id
[
in_session_id_len
]
;
std
::
vector
<
uint8_t
>
in_session_id
(
in_session_id_len
)
;
assert_equals
(
in_session_id_len
,
olm_inbound_group_session_id
(
inbound_session
,
in_session_id
,
in_session_id_len
inbound_session
,
in_session_id
.
data
()
,
in_session_id_len
));
assert_equals
(
in_session_id_len
,
out_session_id_len
);
assert_equals
(
out_session_id
,
in_session_id
,
in_session_id_len
);
assert_equals
(
out_session_id
.
data
()
,
in_session_id
.
data
()
,
in_session_id_len
);
/* decode the message */
/* olm_group_decrypt_max_plaintext_length destroys the input so we have to
copy it. */
uint8_t
msgcopy
[
msglen
];
memcpy
(
msgcopy
,
msg
,
msglen
);
size
=
olm_group_decrypt_max_plaintext_length
(
inbound_session
,
msgcopy
,
msglen
);
uint8_t
plaintext_buf
[
size
];
std
::
vector
<
uint8_t
>
msgcopy
(
msg
);
size
=
olm_group_decrypt_max_plaintext_length
(
inbound_session
,
msgcopy
.
data
(),
msglen
);
std
::
vector
<
uint8_t
>
plaintext_buf
(
size
);
uint32_t
message_index
;
res
=
olm_group_decrypt
(
inbound_session
,
msg
,
msglen
,
plaintext_buf
,
size
,
&
message_index
);
res
=
olm_group_decrypt
(
inbound_session
,
msg
.
data
()
,
msglen
,
plaintext_buf
.
data
()
,
size
,
&
message_index
);
assert_equals
(
plaintext_length
,
res
);
assert_equals
(
plaintext
,
plaintext_buf
,
res
);
assert_equals
(
plaintext
,
plaintext_buf
.
data
()
,
res
);
assert_equals
(
message_index
,
uint32_t
(
0
));
}
...
...
@@ -192,9 +190,9 @@ int main() {
/* init first inbound group session, and decrypt */
std
::
size_t
size
=
olm_inbound_group_session_size
();
uint8_t
session_memory1
[
size
]
;
std
::
vector
<
uint8_t
>
session_memory1
(
size
)
;
OlmInboundGroupSession
*
session1
=
olm_inbound_group_session
(
session_memory1
);
olm_inbound_group_session
(
session_memory1
.
data
()
);
assert_equals
(
0
,
olm_inbound_group_session_is_verified
(
session1
));
std
::
size_t
res
=
olm_init_inbound_group_session
(
...
...
@@ -205,24 +203,24 @@ int main() {
/* olm_group_decrypt_max_plaintext_length destroys the input so we have to
copy it. */
uint8_t
msgcopy
[
msglen
]
;
memcpy
(
msgcopy
,
message
,
msglen
);
size
=
olm_group_decrypt_max_plaintext_length
(
session1
,
msgcopy
,
msglen
);
uint8_t
plaintext_buf
[
size
]
;
std
::
vector
<
uint8_t
>
msgcopy
(
msglen
)
;
memcpy
(
msgcopy
.
data
()
,
message
,
msglen
);
size
=
olm_group_decrypt_max_plaintext_length
(
session1
,
msgcopy
.
data
()
,
msglen
);
std
::
vector
<
uint8_t
>
plaintext_buf
(
size
)
;
uint32_t
message_index
;
memcpy
(
msgcopy
,
message
,
msglen
);
memcpy
(
msgcopy
.
data
()
,
message
,
msglen
);
res
=
olm_group_decrypt
(
session1
,
msgcopy
,
msglen
,
plaintext_buf
,
size
,
&
message_index
session1
,
msgcopy
.
data
()
,
msglen
,
plaintext_buf
.
data
()
,
size
,
&
message_index
);
assert_equals
((
std
::
size_t
)
7
,
res
);
assert_equals
((
const
uint8_t
*
)
"Message"
,
plaintext_buf
,
res
);
assert_equals
((
const
uint8_t
*
)
"Message"
,
plaintext_buf
.
data
()
,
res
);
assert_equals
(
uint32_t
(
0
),
message_index
);
/* export the keys */
size
=
olm_export_inbound_group_session_length
(
session1
);
uint8_t
export_memory
[
size
]
;
std
::
vector
<
uint8_t
>
export_memory
(
size
)
;
res
=
olm_export_inbound_group_session
(
session1
,
export_memory
,
size
,
0
session1
,
export_memory
.
data
()
,
size
,
0
);
assert_equals
(
size
,
res
);
...
...
@@ -231,25 +229,25 @@ int main() {
/* import the keys into another inbound group session */
size
=
olm_inbound_group_session_size
();
uint8_t
session_memory2
[
size
]
;
std
::
vector
<
uint8_t
>
session_memory2
(
size
)
;
OlmInboundGroupSession
*
session2
=
olm_inbound_group_session
(
session_memory2
);
olm_inbound_group_session
(
session_memory2
.
data
()
);
res
=
olm_import_inbound_group_session
(
session2
,
export_memory
,
sizeof
(
export_memory
)
session2
,
export_memory
.
data
(),
export_memory
.
size
(
)
);
assert_equals
((
size_t
)
0
,
res
);
assert_equals
(
0
,
olm_inbound_group_session_is_verified
(
session2
));
/* decrypt the message with the new session */
memcpy
(
msgcopy
,
message
,
msglen
);
size
=
olm_group_decrypt_max_plaintext_length
(
session2
,
msgcopy
,
msglen
);
uint8_t
plaintext_buf2
[
size
]
;
memcpy
(
msgcopy
,
message
,
msglen
);
memcpy
(
msgcopy
.
data
()
,
message
,
msglen
);
size
=
olm_group_decrypt_max_plaintext_length
(
session2
,
msgcopy
.
data
()
,
msglen
);
std
::
vector
<
uint8_t
>
plaintext_buf2
(
size
)
;
memcpy
(
msgcopy
.
data
()
,
message
,
msglen
);
res
=
olm_group_decrypt
(
session2
,
msgcopy
,
msglen
,
plaintext_buf2
,
size
,
&
message_index
session2
,
msgcopy
.
data
()
,
msglen
,
plaintext_buf2
.
data
()
,
size
,
&
message_index
);
assert_equals
((
std
::
size_t
)
7
,
res
);
assert_equals
((
const
uint8_t
*
)
"Message"
,
plaintext_buf2
,
res
);
assert_equals
((
const
uint8_t
*
)
"Message"
,
plaintext_buf2
.
data
()
,
res
);
assert_equals
(
uint32_t
(
0
),
message_index
);
assert_equals
(
1
,
olm_inbound_group_session_is_verified
(
session2
));
}
...
...
@@ -274,9 +272,9 @@ int main() {
/* build the inbound session */
size_t
size
=
olm_inbound_group_session_size
();
uint8_t
inbound_session_memory
[
size
]
;
std
::
vector
<
uint8_t
>
inbound_session_memory
(
size
)
;
OlmInboundGroupSession
*
inbound_session
=
olm_inbound_group_session
(
inbound_session_memory
);
olm_inbound_group_session
(
inbound_session_memory
.
data
()
);
size_t
res
=
olm_init_inbound_group_session
(
inbound_session
,
session_key
,
sizeof
(
session_key
)
-
1
...
...
@@ -287,36 +285,36 @@ int main() {
/* olm_group_decrypt_max_plaintext_length destroys the input so we have to
copy it. */
uint8_t
msgcopy
[
msglen
]
;
memcpy
(
msgcopy
,
message
,
msglen
);
std
::
vector
<
uint8_t
>
msgcopy
(
msglen
)
;
memcpy
(
msgcopy
.
data
()
,
message
,
msglen
);
size
=
olm_group_decrypt_max_plaintext_length
(
inbound_session
,
msgcopy
,
msglen
inbound_session
,
msgcopy
.
data
()
,
msglen
);
memcpy
(
msgcopy
,
message
,
msglen
);
uint8_t
plaintext_buf
[
size
]
;
memcpy
(
msgcopy
.
data
()
,
message
,
msglen
);
std
::
vector
<
uint8_t
>
plaintext_buf
(
size
)
;
uint32_t
message_index
;
res
=
olm_group_decrypt
(
inbound_session
,
msgcopy
,
msglen
,
plaintext_buf
,
size
,
&
message_index
inbound_session
,
msgcopy
.
data
()
,
msglen
,
plaintext_buf
.
data
()
,
size
,
&
message_index
);
assert_equals
(
message_index
,
uint32_t
(
0
));
assert_equals
(
plaintext_length
,
res
);
assert_equals
(
plaintext
,
plaintext_buf
,
res
);
assert_equals
(
plaintext
,
plaintext_buf
.
data
()
,
res
);
/* now twiddle the signature */
message
[
msglen
-
1
]
=
'E'
;
memcpy
(
msgcopy
,
message
,
msglen
);
memcpy
(
msgcopy
.
data
()
,
message
,
msglen
);
assert_equals
(
size
,
olm_group_decrypt_max_plaintext_length
(
inbound_session
,
msgcopy
,
msglen
inbound_session
,
msgcopy
.
data
()
,
msglen
)
);
memcpy
(
msgcopy
,
message
,
msglen
);
memcpy
(
msgcopy
.
data
()
,
message
,
msglen
);
res
=
olm_group_decrypt
(
inbound_session
,
msgcopy
,
msglen
,
plaintext_buf
,
size
,
&
message_index
inbound_session
,
msgcopy
.
data
()
,
msglen
,
plaintext_buf
.
data
()
,
size
,
&
message_index
);
assert_equals
((
size_t
)
-
1
,
res
);
assert_equals
(
...
...
tests/test_message.cpp
View file @
ea13edca
...
...
@@ -49,7 +49,7 @@ TestCase test_case("Message encode test");
std
::
size_t
length
=
olm
::
encode_message_length
(
1
,
10
,
10
,
8
);
assert_equals
(
std
::
size_t
(
35
),
length
);
std
::
uint8_t
output
[
length
];
std
::
uint8_t
output
[
35
];
olm
::
MessageWriter
writer
;
olm
::
encode_message
(
writer
,
3
,
1
,
10
,
10
,
output
);
...
...
tests/test_olm.cpp
View file @
ea13edca
This diff is collapsed.
Click to expand it.
tests/test_olm_decrypt.cpp
View file @
ea13edca
#include
"olm/olm.h"
#include
"unittest.hh"
#include
<vector>
struct
test_case
{
const
char
*
msghex
;
const
char
*
expected_error
;
...
...
@@ -37,14 +39,14 @@ void decode_hex(
}
void
decrypt_case
(
int
message_type
,
const
test_case
*
test_case
)
{
std
::
uint8_t
session_memory
[
olm_session_size
()
]
;
::
OlmSession
*
session
=
::
olm_session
(
session_memory
);
std
::
vector
<
std
::
uint8_t
>
session_memory
(
olm_session_size
()
)
;
::
OlmSession
*
session
=
::
olm_session
(
session_memory
.
data
()
);
std
::
uint8_t
pickled
[
strlen
(
session_data
)
]
;
::
memcpy
(
pickled
,
session_data
,
sizeof
(
pickled
));
std
::
vector
<
std
::
uint8_t
>
pickled
(
strlen
(
session_data
)
)
;
::
memcpy
(
pickled
.
data
()
,
session_data
,
pickled
.
size
(
));
assert_not_equals
(
::
olm_error
(),
::
olm_unpickle_session
(
session
,
""
,
0
,
pickled
,
sizeof
(
pickled
))
::
olm_unpickle_session
(
session
,
""
,
0
,
pickled
.
data
(),
pickled
.
size
(
))
);
std
::
size_t
message_length
=
strlen
(
test_case
->
msghex
)
/
2
;
...
...
@@ -67,12 +69,12 @@ void decrypt_case(int message_type, const test_case * test_case) {
assert_not_equals
(
::
olm_error
(),
max_length
);
uint8_t
plaintext
[
max_length
]
;
std
::
vector
<
uint8_t
>
plaintext
(
max_length
)
;
decode_hex
(
test_case
->
msghex
,
message
,
message_length
);
olm_decrypt
(
session
,
message_type
,
message
,
message_length
,
plaintext
,
max_length
plaintext
.
data
()
,
max_length
);
free
(
message
);
}
...
...
tests/test_olm_sha256.cpp
View file @
ea13edca
#include
"olm/olm.h"
#include
"unittest.hh"
#include
<vector>
int
main
()
{
{
TestCase
(
"Olm sha256 test"
);
std
::
uint8_t
utility_buffer
[
::
olm_utility_size
()
]
;
::
OlmUtility
*
utility
=
::
olm_utility
(
utility_buffer
);
std
::
vector
<
std
::
uint8_t
>
utility_buffer
(
::
olm_utility_size
()
)
;
::
OlmUtility
*
utility
=
::
olm_utility
(
utility_buffer
.
data
()
);
assert_equals
(
std
::
size_t
(
43
),
::
olm_sha256_length
(
utility
));
std
::
uint8_t
output
[
43
];
...
...
tests/test_pk.cpp
View file @
ea13edca
...
...
@@ -5,6 +5,7 @@
#include
"unittest.hh"
#include
<iostream>
#include
<vector>
int
main
()
{
...
...
@@ -13,8 +14,8 @@ int main() {
TestCase
test_case
(
"Public Key Encryption/Decryption Test Case 1"
);
std
::
uint8_t
decryption_buffer
[
olm_pk_decryption_size
()
]
;
OlmPkDecryption
*
decryption
=
olm_pk_decryption
(
decryption_buffer
);
std
::
vector
<
std
::
uint8_t
>
decryption_buffer
(
olm_pk_decryption_size
()
)
;
OlmPkDecryption
*
decryption
=
olm_pk_decryption
(
decryption_buffer
.
data
()
);
std
::
uint8_t
alice_private
[
32
]
=
{
0x77
,
0x07
,
0x6D
,
0x0A
,
0x73
,
0x18
,
0xA5
,
0x7D
,
...
...
@@ -34,25 +35,25 @@ std::uint8_t bob_private[32] = {
const
std
::
uint8_t
*
bob_public
=
(
std
::
uint8_t
*
)
"3p7bfXt9wbTTW2HC7OQ1Nz+DQ8hbeGdNrfx+FG+IK08"
;
std
::
uint8_t
pubkey
[
::
olm_pk_key_length
()
]
;
std
::
vector
<
std
::
uint8_t
>
pubkey
(
::
olm_pk_key_length
()
)
;
olm_pk_key_from_private
(
decryption
,
pubkey
,
sizeof
(
pubkey
),
pubkey
.
data
(),
pubkey
.
size
(
),
alice_private
,
sizeof
(
alice_private
)
);
assert_equals
(
alice_public
,
pubkey
,
olm_pk_key_length
());
assert_equals
(
alice_public
,
pubkey
.
data
()
,
olm_pk_key_length
());
uint8_t
*
alice_private_back_out
=
(
uint8_t
*
)
malloc
(
olm_pk_private_key_length
());
olm_pk_get_private_key
(
decryption
,
alice_private_back_out
,
olm_pk_private_key_length
());
assert_equals
(
alice_private
,
alice_private_back_out
,
olm_pk_private_key_length
());
free
(
alice_private_back_out
);
std
::
uint8_t
encryption_buffer
[
olm_pk_encryption_size
()
]
;
OlmPkEncryption
*
encryption
=
olm_pk_encryption
(
encryption_buffer
);
std
::
vector
<
std
::
uint8_t
>
encryption_buffer
(
olm_pk_encryption_size
()
)
;
OlmPkEncryption
*
encryption
=
olm_pk_encryption
(
encryption_buffer
.
data
()
);
olm_pk_encryption_set_recipient_key
(
encryption
,
pubkey
,
sizeof
(
pubkey
));
olm_pk_encryption_set_recipient_key
(
encryption
,
pubkey
.
data
(),
pubkey
.
size
(
));
const
size_t
plaintext_length
=
14
;
const
std
::
uint8_t
*
plaintext
=
(
std
::
uint8_t
*
)
"This is a test"
;
...
...
@@ -60,27 +61,27 @@ const std::uint8_t *plaintext = (std::uint8_t *) "This is a test";
size_t
ciphertext_length
=
olm_pk_ciphertext_length
(
encryption
,
plaintext_length
);
std
::
uint8_t
*
ciphertext_buffer
=
(
std
::
uint8_t
*
)
malloc
(
ciphertext_length
);
std
::
uint8_t
output_buffer
[
olm_pk_mac_length
(
encryption
)
]
;
std
::
uint8_t
ephemeral_key
[
olm_pk_key_length
()
]
;
std
::
vector
<
std
::
uint8_t
>
output_buffer
(
olm_pk_mac_length
(
encryption
)
)
;
std
::
vector
<
std
::
uint8_t
>
ephemeral_key
(
olm_pk_key_length
()
)
;
olm_pk_encrypt
(
encryption
,
plaintext
,
plaintext_length
,
ciphertext_buffer
,
ciphertext_length
,
output_buffer
,
sizeof
(
output_buffer
),
ephemeral_key
,
sizeof
(
ephemeral_key
),
output_buffer
.
data
(),
output_buffer
.
size
(
),
ephemeral_key
.
data
(),
ephemeral_key
.
size
(
),
bob_private
,
sizeof
(
bob_private
)
);
assert_equals
(
bob_public
,
ephemeral_key
,
olm_pk_key_length
());
assert_equals
(
bob_public
,
ephemeral_key
.
data
()
,
olm_pk_key_length
());
size_t
max_plaintext_length
=
olm_pk_max_plaintext_length
(
decryption
,
ciphertext_length
);
std
::
uint8_t
*
plaintext_buffer
=
(
std
::
uint8_t
*
)
malloc
(
max_plaintext_length
);
olm_pk_decrypt
(
decryption
,
ephemeral_key
,
sizeof
(
ephemeral_key
),
output_buffer
,
sizeof
(
output_buffer
),
ephemeral_key
.
data
(),
ephemeral_key
.
size
(
),
output_buffer
.
data
(),
output_buffer
.
size
(
),
ciphertext_buffer
,
ciphertext_length
,
plaintext_buffer
,
max_plaintext_length
);
...
...
@@ -96,8 +97,8 @@ free(plaintext_buffer);
TestCase
test_case
(
"Public Key Decryption pickling"
);
std
::
uint8_t
decryption_buffer
[
olm_pk_decryption_size
()
]
;
OlmPkDecryption
*
decryption
=
olm_pk_decryption
(
decryption_buffer
);
std
::
vector
<
std
::
uint8_t
>
decryption_buffer
(
olm_pk_decryption_size
()
)
;
OlmPkDecryption
*
decryption
=
olm_pk_decryption
(
decryption_buffer
.
data
()
);
std
::
uint8_t
alice_private
[
32
]
=
{
0x77
,
0x07
,
0x6D
,
0x0A
,
0x73
,
0x18
,
0xA5
,
0x7D
,
...
...
@@ -108,37 +109,37 @@ std::uint8_t alice_private[32] = {
const
std
::
uint8_t
*
alice_public
=
(
std
::
uint8_t
*
)
"hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmoK"
;
std
::
uint8_t
pubkey
[
olm_pk_key_length
()
]
;
std
::
vector
<
std
::
uint8_t
>
pubkey
(
olm_pk_key_length
()
)
;
olm_pk_key_from_private
(
decryption
,
pubkey
,
sizeof
(
pubkey
),
pubkey
.
data
(),
pubkey
.
size
(
),
alice_private
,
sizeof
(
alice_private
)
);
const
uint8_t
*
PICKLE_KEY
=
(
uint8_t
*
)
"secret_key"
;
std
::
uint8_t
pickle_buffer
[
olm_pickle_pk_decryption_length
(
decryption
)
]
;
std
::
vector
<
std
::
uint8_t
>
pickle_buffer
(
olm_pickle_pk_decryption_length
(
decryption
)
)
;
const
uint8_t
*
expected_pickle
=
(
uint8_t
*
)
"qx37WTQrjZLz5tId/uBX9B3/okqAbV1ofl9UnHKno1eipByCpXleAAlAZoJgYnCDOQZDQWzo3luTSfkF9pU1mOILCbbouubs6TVeDyPfgGD9i86J8irHjA"
;
olm_pickle_pk_decryption
(
decryption
,
PICKLE_KEY
,
strlen
((
char
*
)
PICKLE_KEY
),
pickle_buffer
,
sizeof
(
pickle_buffer
)
pickle_buffer
.
data