obfany 0.1.1

Compiletime string and number constant obfuscation for Rust
Documentation 
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

String and Number Obfuscation
==============================

> Forked from [obfstr](https://github.com/CasualX/obfstr) by CasualX — adds `obfnum!` macro for numeric constant obfuscation.

[![MIT License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![crates.io](https://img.shields.io/crates/v/obfany.svg)](https://crates.io/crates/obfany)
[![docs.rs](https://docs.rs/obfany/badge.svg)](https://docs.rs/obfany)
[![Build status](https://github.com/jeanzuck/obfany/workflows/CI/badge.svg)](https://github.com/jeanzuck/obfany/actions)

Compiletime string and number constant obfuscation for Rust.

The string constant itself is embedded in obfuscated form and deobfuscated locally.
This reference to a temporary value must be used in the same statement it was generated.
See the documentation for more advanced use cases.

Examples
--------

The `obfstr!` macro returns the deobfuscated string as a temporary value:

```rust
use obfany::obfstr as s;
assert_eq!(s!("Hello 🌍"), "Hello 🌍");
```

The `wide!` macro provides compiletime utf16 string constants:

```rust
let expected = &['W' as u16, 'i' as u16, 'd' as u16, 'e' as u16, 0];
assert_eq!(obfany::wide!("Wide\0"), expected);
```

The `random!` macro provides compiletime random values:

```rust
const RND: i32 = obfany::random!(u8) as i32;
assert!(RND >= 0 && RND <= 255);
```

Compiletime random values are based on `file!()`, `line!()`, `column!()` and a fixed seed to ensure reproducibility.
This fixed seed is stored as text in the environment variable `OBFANY_SEED` and can be changed as desired.

The `obfnum!` macro obfuscates numeric constants:

```rust
let secret: u32 = obfany::obfnum!(0x1234_u32);
assert_eq!(secret, 0x1234_u32);
```

Always use a typed literal suffix (e.g. `0x1234_u32`, `-9999_i64`, `3.14_f32`) to ensure correctness.
Supports all primitive numeric types: `u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`, `i64`, `i128`, `usize`, `isize`, `f32`, `f64`.
The value is stored XOR-encrypted in the binary and decrypted at runtime.

Credits
-------

This project is a fork of [obfstr](https://github.com/CasualX/obfstr)
by [CasualX](https://github.com/CasualX), licensed under MIT.

Changes from upstream:
- Renamed crate to `obfany`
- Added `obfnum!` macro for compiletime numeric constant obfuscation

License
-------

Licensed under [MIT License](https://opensource.org/licenses/MIT), see [license.txt](license.txt).

### Contribution


Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, shall be licensed as above, without any additional terms or conditions.