cry-me - CRY.ME (CRYptographic MEssaging application)

项目说明

CRY.ME - A Flawed Messaging Application for Educational Purposes

The CRY.ME project

The CRY.ME project consists in a secure messaging application based on the Matrix protocol containing many cryptographic deliberately introduced for educational purposes. The CRY.ME application has been specified and de by ANSSI and CryptoExperts to provide a practical security challenge especially targeting cryptography.

The application presents many different classes of to identify and, whene, to exploit. The scope of the introduced in the CRY.ME covers many of the classical domains of cryptography.

Disclaimer

All the code and documentation associated with CRY.ME are flawed and have been made specifically in the context of challenging cryptographic competencies.

It MUST NOT BE USED in any context other than educational purposes.
We deny any responsability when using CRY.ME as a messaging application, or any
part of the CRY.ME source code, in other contexts.

Authors

The authors of CRY.ME are from ANSSI and CryptoExperts.

ANSSI:
* Jérémy JEAN
* Louiza KHATI
* Ange MARTINELLI
* Chrysanthi MA

CryptoExperts:
* Sonia BELAID
* Ryad BENADJILA
* Thibauld FENEUIL
* Matthieu RIVAIN
* Abdul Rahman TALEB

For questions or remarks regarding CRY.ME, please fill issues on this repository or send an
email to .

License

The CRY.ME project is released under the Apache 2.0 license, please check
the LICENSE file at the root folder of the project.

CRY.ME heavily relies on source code from the Android element ()
project, the Matrix SDK project (), and the
Android Yubikit () project. These three projects
are under the Apache 2.0 license as well.

The CRY.ME application

CRY.ME is based on Android element (), and it shares
many features with the original messaging application. Please check the element user guide
for more details on how the application works.

For a basic "getting started" documentation, you can refer to the brief howto.

The CRY.ME application specifications

Cryptographic specifications for the CRY.ME application can be found in the cryme_docs folder. We provide two documents for the specifications, as well as the security target that can be used for an e to describe the scope to analyze.
The first document crypto_specs_without_vulns contains the specifications without any mention to the cryptographic and should be the one to use by anyone who wants to give the challenge a try.
The second document crypto_specs_with_vulns contains the full cryptographic specifications with mentions of all the introduced in the application. It can be seen as the solution to the challenge.

NOTE: the documents in cryme_docs are in French. This is mainly due to CRY.ME being
the result of a French challenge. We might consider translating parts of this documentation
in the future. Anyways, any help on this translation through Pull Requests is welcome!

The CRY.ME Android source code bundle for security analysis

CRY.ME uses element as a basis for the messaging application.
In cryme_app, all the source code of the application is present.
Beware that this source code is annotated with the
(using comments with CRY.ME.VULN.XX, XX being a number).

Of course, for someone wanting to explore the source code without
any information about the , these annotations are spoilers.
This is why we provide a dedicated way of bundling this source code without
the annotations. To do so, go to the cryme_app folder and execute:

The compressed bundle will be created in cry.me.src.bundle.tar.gz: you can uncompress it and explore it.
The bundling script should only have python3 and tar as dependencies, but we also provide a
Dockerfile (you will need docker):

The CRY.ME Android compilation

Pre-built packages

For those who do not want to recompile the CRY.ME application from scratch, it is possible
to get the apk files from the following URL:

Once downloaded, you can extract this archive in the cryme_app folder, which will create a build/ subfolder.

The bundle contains debug and release apk both for the CRY.ME application, and for
the Yubikit "demo" in order to test your Yubikey on Android if needed.
Once untared, the CRY.ME debug apk files are in build/cryme/gplay/debug/and the release ones in
build/cryme/gplay/release.

The ebug.apk and elease-unsigned.apk
are of particular interest as they are "uni" and should be installable on physical devices
or emulators (both arm and x86 flavours) with Android API level at least 29.

Please be aware, however, that the release packages are not signed, and hence
not directly installable on target devices (which is not the case of debug packages). Signing apk
release packages is out of the scope of the project, please refer to the appropriate Android
resources to achieve this.

Compilation from scratch

It is possible to compile the CRY.ME project (producing apk files for Android) using the
following command:

This supposes that the following dependencies are installed on your system:
openjdk-11-jdk-headless, make, gradle, git, curl.
Depending on your system, you may need to adapt your en to launch the build:

If you do not want to bother with all these dependencies, a Docker is also a (you will need
docker):

This will create a cryme_app/build folder with the debug and release
apk files.

We ha to make compilation as easy and transparent as possible, but you might
also want to install Android Studio and compile CRY.ME by your own means. If so,
please follow the steps in the dedicated documentation.
Using Android Studio implies to install a rather hea, but allows to use
the debugger that can come handy when analyzing the application.

The CRY.ME server

Due to the CRY.ME ser dependencies (mostly for the embedded Synapse server), we
provide a docker-compose file to lauch it. Launching an instance of the server is
as easy as going to the cryme_server folder and executing (you will need docker and
docker-compose to be installed on your system):

NOTE: this command supposes that your user can manage Docker with non-root user. You might
either follow this documentation,
or use sudo for this make command.

The SYNAPSE_SER en is used to provide the FQDN name of the server
(needed by Synapse). We use cryme.fr in the command above.
If e goes well, you should see three containers successfully started: cryme-db,
cryme-synapse and cryme-nginx.

Note that we provide two files for docker-compose: the default one (docker-compose.yml)
used by the above make command pulls a public image from DockerHub that has been prebuilt
for a simpler usage. The second one (docker-compose.build.yml) can be used in case you want
to rebuild the ser. While this is not necessary for using the application, it might
come in handy during a deeper analysis of the application. You can force the local build of
the cryme-synapse docker with:

The users and con databases are handled by the cryme-db container: they should be
consistent across executions of the server. If you want to purge the database and
get a clean state with empty databases, you can execute:

Beware that with this command, you will loose all the existing users and con!

The CRY.ME application emulation

O of the emulated platform

In order to make testing CRY.ME easier, we also provide a way to easily test
the application on a single computer. We make use of a ser
on localhost, and as many emulators instances communicating with it as CRY.ME
users you want to emulate. All the sequel have been tested on a x86_64 Linux en
with the following dependencies installed: docker, bash, curl, swig, pcscd, libpcsclite-dev
and yubikey-manager.
Although any Android emulator image could theoretically be used, the ones we provide
are specifically suited to test CRY.ME for two reasons: first of all, they use
a custom kernel and system modifications allowing for USB passthough (for communicating with physical Yubikeys),
and secondly some system files have been modified for easy network lookups on
localhost (for communicating with the local ser).

Since CRY.ME makes use of Yubikeys as authentication tokens, you will need
as many Yubikeys as the number of CRY.ME users you wan to emulate.

NOTE: emulation of CRY.ME uses images with around 12 GB. Beware of
this rather large size that will grow with the number of users when
creating multiple images!

Launching the ser for emulation

First of all, launch an instance of the ser the server name cryme.fr
(beware that this name is important to keep as it is embedded in the
emulator images DNS lookup):

You can modify the SYNAPSE_SER with the name of another server
instance running on a machine elsewhere in the network/internet, however you
should make sure that this name can be properly resolved by a DNS server (which
should be the case if the URL is indeed accessible, e.g., from a browser).

Creating the CRY.ME users images for emulation

Then, go to the cryme_app_emulation folder and proceed with some
steps. First, we will create as many emulators instances as we ha
to create. For the sake of the example, we take two users (1 and 2) in the
following. This supposes that you have two distinct Yubikeys, each one
associated with each user: let's call them Yubikey 1 and Yubikey 2.

Create the CRY.ME user 1 emulator instance. Plug Yubikey 1 and execute the
create_emulator_image.sh bash script (be sure that only one Yubikey is
plugged in at a time):

Do the same with Yubikey 2 and user 2 (replacing 1 by 2 of course in the
previous command line). This might take a while as the base emulator images
must be fetched and uncompressed. You can also provide as a second argument
the Yubikey serial number to be used for the image to create: in this case,
the script does not check that the Yubikey is plugged in (but beware that the
serial number must be valid as during execution il will be checked against
a physical Yubikey):

All the created images can be cleaned with the same create_emulator_image.sh script using
clean as a first argument (all the images will be clean without additional argument), and
the image's user number to clean as a second optional argument:

Launching the emulation images for the users

Then, the instances can be launched using the launch_emulator_usb.sh bash script:

Of course, the Yubikey associated with the user must be plugged in. On the first launch, you
might be asked to fetch and untar the SDK using make sdk_untar in the cryme_app folder: proceed
with this (it should be done once). An emulator window should be opened.

Finally, you can install the compiled CRY.ME application in the emulator using adb. Supposing that the
build folder is created following a proper compilation, you can go to the cryme_app folder and
execute the make app_install command.

Please ensure that only one instance of the emulator is running when installing (so that there is no
ambiguity for adb to know where to install the application).

After the installation of the application on every instance for every user, you can begin to use the CRY.ME app while
launching all the instances and sign up/sign in users. Please ensure that all the Yubikeys associated to
the users you "emulate" are plugged in when you launch the associated images and do not unplug them during
your emulation session: qemu USB passthrough is not very resilient to hot (un)plugging.
When asked for a server, enter cryme.fr and accept to "trust" it (this is asked because of the self-signed
TLS certificates on the demo server). Since the Yubikey might not
be necessary after a Sign Up / Sign In, you can also force launching the emulator instance associated to a user
with noyubi as a second argument:

NOTE: keep all the necessary Yubikeys plugged in during the whole emulation session.

Emulation demo video

Here is a little demo for the full workflow of local CRY.ME emulation:

NOTE: in this demo video, during the last part emulating CRY.ME with two users, the two Yubikeys
were simultaneously plugged in during the whole emulation session. Please be aware that the emulator does not support
hot (un)plugging, so do not unplug you Yubikeys when they are needed (or you will have to launch the
instances again).

项目信息

开发语言：Kotlin

Star 数：181

技术要点

该项目属于CTF思路方向的开源资源，代码结构清晰，适合安全研究人员学习参考。项目围绕CRY.ME (CRYptographic MEssaging application)展开，提供了可运行的实现，对理解相关安全机制、工具原理与攻防技术具有较高的研究价值。

从技术实现角度看，此类项目的核心在于对底层原理的深入理解与工程化落地。开发者在研究过程中可以结合官方文档与社区讨论，梳理项目的初始化流程、核心模块职责与数据流转，逐步掌握其中的技术细节与设计思路。

使用与学习建议

1. 下载源码压缩包，解压到本地环境。

2. 根据项目类型准备对应的运行环境与依赖。

3. 按照 README 中的步骤完成配置与部署。

4. 在隔离的测试环境中运行验证，避免影响生产系统。

免责声明

本资源来源于开源社区，仅供安全研究、技术学习与合法授权范围内的攻防演练使用，请勿用于任何非法或侵害他人权益的用途。使用本项目产生的一切后果由使用者自行承担。