avx-nucleus 0.1.0

Atomic-level operations - Foundation of avx cryptography stack
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
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

# avx Nucleus


**Low-level cryptographic primitives and bit-manipulation operations**

[![Crates.io](https://img.shields.io/crates/v/avx-nucleus.svg)](https://crates.io/crates/avx-nucleus)
[![Documentation](https://docs.rs/avx-nucleus/badge.svg)](https://docs.rs/avx-nucleus)
[![License](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue.svg)](https://github.com/avilaops/arxis/blob/main/LICENSE-MIT)

## Overview


`avx-nucleus` provides foundational building blocks for cryptographic operations, including constant-time comparisons, bit manipulation, SIMD operations, and mathematical primitives used throughout the avx ecosystem.

## Features


- **Constant-Time Operations**: Timing-attack resistant comparisons and operations
- **Bit Manipulation**: Efficient bit-level operations for 256-bit, 512-bit, and larger integers
- **SIMD Support**: Hardware-accelerated operations for x86_64 architectures
- **Arithmetic Primitives**: Addition, subtraction, multiplication, division for big integers
- **Modular Arithmetic**: Montgomery multiplication and reduction
- **Endianness Conversions**: Little-endian byte array operations

## Modules


### `bits`

Low-level bit manipulation and arithmetic operations:
- `u256_ops`: 256-bit unsigned integer operations
- `u512_ops`: 512-bit unsigned integer operations
- `u1024_ops`: 1024-bit unsigned integer operations
- `u2048_ops`: 2048-bit unsigned integer operations
- `u4096_ops`: 4096-bit unsigned integer operations

### `simd`

SIMD-accelerated operations (x86_64):
- Parallel processing for cryptographic operations
- Hardware acceleration when available

### Core Operations


#### Constant-Time Equality

```rust
use avx_nucleus::bits::eq256;

let a = [1u64, 2, 3, 4];
let b = [1u64, 2, 3, 4];
assert!(eq256(&a, &b));
```

#### Big Integer Arithmetic

```rust
use avx_nucleus::bits::u256_ops::*;

let a = [100u64, 0, 0, 0];
let b = [50u64, 0, 0, 0];
let (sum, carry) = add256(&a, &b);
assert_eq!(sum[0], 150);
```

#### Division with Remainder

```rust
use avx_nucleus::bits::u256_ops::*;

let dividend = [107u64, 0, 0, 0];
let divisor = [10u64, 0, 0, 0];
let (quotient, remainder) = div256(&dividend, &divisor);
assert_eq!(quotient[0], 10);
assert_eq!(remainder[0], 7);
```

## Security Considerations


All operations in this crate are designed with security in mind:

- **Constant-time operations** prevent timing attacks
- **No branching** on secret data
- **Careful carry propagation** in arithmetic operations
- **Secure memory handling** for sensitive data

## Performance


The crate is optimized for:
- Zero-cost abstractions
- Minimal allocations (mostly stack-based)
- Cache-friendly memory access patterns
- SIMD acceleration where available

## Testing


Run the test suite:
```bash
cargo test
```

Current test coverage: **47 tests passing**

## Dependencies


- `core` only (no_std compatible)
- Optional SIMD support requires x86_64 architecture

## License


Part of the avx cryptographic suite.

## Related Crates


- `avx-primitives`: High-level big integer types using these primitives
- `avx-crypto`: Cryptographic algorithms built on these foundations
- `avx-atom`: Thread-safe atomic operations

## Contributing


When adding new operations:
1. Ensure constant-time behavior for security-sensitive code
2. Add comprehensive tests including edge cases
3. Document security properties and performance characteristics
4. Maintain no_std compatibility