Commands

Every command, in order

Everything you type to set up and use Raven and the Raven node. One line with each command says what it does, and its Copy button copies exactly the command shown. Commands that differ by system are marked macOS, Linux or Windows.

What works in a release build today

Messages between two computers on the same local network, sealed end to end, with signed receipts. Tor, groups, friends who keep mail for each other, the long message horizon, the internet path and Bluetooth nearby are lab features: built and tested, but off in release builds. They are not listed here as steps.

Nothing has had an independent security review yet. Status on GitHub

Step 01

Install the tools

Raven builds from source. You need Git, Rust and a C compiler. Install them once, with the commands for your system.

macOS

Installs the Xcode command line tools: Git and a C compiler.
```
xcode-select --install
```
Installs Rust with rustup, its official installer. Open a new terminal window afterwards.
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

Linux (Debian, Ubuntu)

On other distributions, install gcc, Git and curl with their own package manager.

Updates the package list, then installs a C compiler, Git and curl.
```
sudo apt-get update
sudo apt-get install build-essential git curl
```
Installs Rust with rustup, its official installer. Open a new terminal window afterwards.
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

Windows (PowerShell)

Run every Windows command in PowerShell. Open a new PowerShell window after these three.

Installs Git.
```
winget install --id Git.Git -e
```
Installs Rust with rustup.
```
winget install --id Rustlang.Rustup -e
```

Installs the Visual Studio Build Tools with the C++ desktop workload, the compiler Rust needs on Windows.

winget install --id Microsoft.VisualStudio.2022.BuildTools -e --override "--quiet --wait --add Microsoft.VisualStudio.Workload.VCTools --includeRecommended"

Every system

Brings Rust to the current stable version. Raven is tested with Rust 1.98.
```
rustup update stable
```

Step 02

Get the source and build

The same three commands on every system. The source is Raven core on GitHub.

Gets the Raven source from GitHub.

git clone https://github.com/Raven-ASHCO/raven-core.git

Goes into its node folder, the Rust workspace. The install commands in the next step run from here.
```
cd raven-core/node
```
Builds the raven command and the Raven node, with the dependency versions locked. The first build takes a few minutes.
```
cargo build --release --locked -p ash -p raven-node
```
Runs the new raven command and lists every command it has.
```
./target/release/raven --help
```

Step 03

Run the Raven node

The Raven node is the background program that sends and receives your messages. The install script for your system copies raven and the Raven node to a folder of your own and starts the node at every login. With auto it listens on your networks, and only your contacts get an answer. In this build that means port 7420 on every network of this computer, so others on the network can see that something listens. Without auto it listens on this computer only, and friends cannot reach you.

macOS

Builds and installs raven and the Raven node in your home folder, creates your identity if you have none, and starts the node at every login.
```
RAVEN_LAN_LISTEN=auto bash scripts/install/macos_launchd.sh
```
Lets this terminal find raven. Add the same line to your shell profile to keep it.
```
export PATH="$HOME/.local/bin:$PATH"
```

Only if the macOS firewall is on: lets friends on your network reach the Raven node. If macOS asks for Local Network access for it, allow it.

sudo /usr/libexec/ApplicationFirewall/socketfilterfw --add ~/.local/bin/raven-node
sudo /usr/libexec/ApplicationFirewall/socketfilterfw --unblockapp ~/.local/bin/raven-node

Linux

On a computer without a desktop keyring, the service needs your passphrase in a file only you can read: see the Linux install guide.

Builds and installs raven and the Raven node in your home folder, creates your identity if you have none, and starts the node as a systemd user service.
```
RAVEN_LAN_LISTEN=auto bash scripts/install/linux_systemd_user.sh
```
Lets this terminal find raven. Add the same line to your shell profile to keep it.
```
export PATH="$HOME/.local/bin:$PATH"
```
Only if ufw is on: lets friends on a typical home network reach the Raven node. Use the range of your own network.
```
sudo ufw allow from 192.168.0.0/16 to any port 7420 proto tcp
```

Windows (PowerShell)

Builds and installs raven and the Raven node in your local app data folder and starts the node at every sign in. It prints two firewall rules for your private network; run them in a PowerShell opened as administrator.
```
powershell -ExecutionPolicy Bypass -File scripts\install\windows_service.ps1 -LanListen auto
```

Lets this PowerShell window find raven.

$env:Path += ";$env:LOCALAPPDATA\RavenNode"

Instead of the login service

Listens on your networks in this window until you close it. Stop the login service first; raven doctor says how.
```
raven listen
```

Step 04

Your identity and your card

From here on, the commands are the same on every system.

Opens the Raven terminal app, which walks you through setup, friends and chats. The commands below do the same from the command line.
```
raven
```
Creates your identity on this computer. The private key stays in the protected key store of your system. On macOS and Linux the install script already ran it; running it again only shows your identity.
```
raven init
```
Publishes a fresh signed key bundle, which a friend needs to start a secure session with you. raven init already published the first one.
```
raven prekey publish
```
Shows your address, your ten security words and your invite line.
```
raven whoami
```
Prints your card: one line with your address, key and fingerprint. Send it to your friend.
```
raven whoami --card
```

Step 05

Add a friend

Both of you add each other. Messages only arrive between people who have added each other. Lily stands for the name you give your friend; it stays on your computer.

Adds your friend from the card they sent you.

raven contact add --card '<card line>' --petname Lily

Checks the ten security words: your friend reads theirs to you on a call or in person, and you type them. Raven pins their key only when every word matches. The word list is a draft and may still change.
```
raven contact verify Lily
```
Or adds and checks in one step, with the words you heard from your friend. Never use words that came in the same message as the card.
```
raven contact add --card '<card line>' --petname Lily --verify-fp '<their 10 words>'
```

Your local address

Finding friends on a new network by itself is off in release builds, so each of you types the local address of the other once. These show your own address, to read to your friend.

macOS: shows the WiFi address of this Mac (en0 on most Macs).
```
ipconfig getifaddr en0
```
Linux: shows the addresses of this computer.
```
ip -br addr
```
Windows: shows the IPv4 addresses of this PC.
```
Get-NetIPAddress -AddressFamily IPv4
```

Save the address of your friend

Saves the local address of your friend, the one they read to you, with port 7420.
```
raven contact set-addr Lily --lan 192.168.1.31:7420
```
Lists your friends, whether each one is verified and how Raven reaches them.
```
raven contact list
```

Step 06

Send and read

A message is sent only inside a secure session with your friend, and shows as delivered only after a signed receipt comes back.

Sends one message: type it, then end the input with Ctrl D (on Windows, Ctrl Z and then Enter). The text never goes on the command line, so it stays out of your shell history.
```
raven send --contact Lily
```
Opens a live chat with Lily. Inside, /help lists what you can do, /verify shows your security words and /back leaves.
```
raven send --contact Lily --chat
```
Shows the messages you received.
```
raven inbox
```
Shows the messages still waiting to be delivered, and the ones that finished recently.
```
raven outbox
```
Tries one waiting message again now. Use the id that raven outbox shows.
```
raven outbox retry 1a2b3c4d
```

Step 07

Check and fix

Shows your identity, your friends and whether this computer can send and receive.
```
raven status
```
Checks your setup and says what to do next.
```
raven doctor
```
Shows whether friends on your network can reach this computer.
```
raven lan status
```
Stops using the local network at once, on a network you do not trust such as a cafe or a hotel. Your messages wait.
```
raven lan off
```
Uses the local network again.
```
raven lan on
```
Lists every command. Add --help after any command for its options.
```
raven --help
```

Step 08

Lock, chats and erase

Stops Raven on this computer now: friends cannot reach you, and sending does not start it again.
```
raven lock
```
Starts Raven again after a lock.
```
raven unlock
```
Keeps your chats on this computer for 90 days (7d, 30d, 90d or always). Older chats are deleted here, not on the computers of your friends.
```
raven chats keep 90d
```
Deletes your chat with Lily on this computer. Your friend keeps their copy.
```
raven chats delete --petname Lily
```
Shows what Raven encrypts on this computer and how long it keeps your chats.
```
raven privacy status
```
Erases Raven from this computer: your identity, friends, chats and waiting messages. It asks you to type erase first, and there is no undo.
```
raven erase
```

RDAP

RDAP: agents that ask each other for help

RDAP is experimental and separate from the Raven node: it keeps its own keys. Tasks and answers are signed, not encrypted. The RDAP source will be on GitHub soon. Until then, RDAP in plain words says what it does and what works today.

Where to read more

These commands were checked against the help of the raven command in the source on GitHub. The install guides there go further: networks without the internet, firewalls, and running a node for a long time.

Raven install guides → Security words → Without the internet → Back to Raven →