Easily and securely share files from the command line. A fully featured Firefox Send client.
ffsend is a command-line tool designed to securely share files and directories via encrypted links using the Firefox Send service. It provides developers and security-conscious users with a reliable way to transfer sensitive data while maintaining privacy and control over shared content.
Key Features:
Encrypted File Sharing: Files are encrypted on the client side before being uploaded, ensuring that secrets remain private.
Optional Password Protection: Secure access with passwords for added layers of protection.
Download Limits and Expiry: Set custom download limits (up to 20) and expiry times (default 24 hours) to control access.
QR Code Generation: Easily share links via QR codes for seamless mobile access.
Custom Host Support: Use your own Send-compatible server or the default host provided by the developer.
Audience & Benefit:
Ideal for developers, IT professionals, and anyone needing secure file sharing. ffsend enhances workflow efficiency while reducing risks associated with insecure file transfers. Its command-line interface makes it perfect for scripting and automation, ensuring seamless integration into existing workflows.
README
Notice: the default Send host is provided by @timvisee
(info).
Please consider to donate and help keep it running.
ffsend
> Easily and securely share files from the command line.
> A Send client.
Easily and securely share files and directories from the command line through a
safe, private and encrypted link using a single simple command.
Files are shared using the Send service and may be up
to 1GB. Others are able to download these files with this tool, or through
their web browser.
All files are always encrypted on the client, and secrets are never shared with
the remote host. An optional password may be specified, and a default file
lifetime of 1 (up to 20) download or 24 hours is enforced to ensure your stuff
does not remain online forever.
This provides a secure platform to share your files.
Find out more about security here.
ffsend can be installed via winget on supported platforms, providing a quick and reliable setup process for users across Linux, macOS, Windows, and other operating systems.
The public Send service that is used as default host is provided by
@timvisee (info).
This application is not affiliated with Firefox or
Mozilla in any way.
Note: this tool is currently in beta, as some extra desired features are yet to be implemented
Features
Fully featured and friendly command line tool
Upload and download files and directories securely, always encrypted on the client
Additional password protection, generation and configurable download limits
File and directory archiving and extraction
Built-in share URL shortener and QR code generator
Supports Send v3 (current) and v2
History tracking your files for easy management
Ability to use your own Send hosts
Inspect or delete shared files
Accurate error reporting
Streaming encryption and uploading/downloading, very low memory footprint
For a list of upcoming features and ideas, take a look at the
current open issues over on GitLab.
Usage
Easily upload and download:
# Simple upload
$ ffsend upload my-file.txt
https://send.vis.ee/#sample-share-url
# Advanced upload
# - Specify a download limit of 1
# - Specify upload expiry time of 5 minutes
# - Enter a password to encrypt the file
# - Archive the file before uploading
# - Copy the shareable link to your clipboard
# - Open the shareable link in your browser
$ ffsend upload --downloads 1 --expiry-time 5m --password --archive --copy --open my-file.txt
Password: ******
https://send.vis.ee/#sample-share-url
# Upload to your own host
$ ffsend u -h https://example.com/ my-file.txt
https://example.com/#sample-share-url
# Simple download
$ ffsend download https://send.vis.ee/#sample-share-url
Inspect remote files:
# Check if a file exists
$ ffsend exists https://send.vis.ee/#sample-share-url
Exists: yes
# Fetch remote file info
$ ffsend info https://send.vis.ee/#sample-share-url
ID: b087066715
Name: my-file.txt
Size: 12 KiB
MIME: text/plain
Downloads: 0 of 10
Expiry: 18h2m (64928s)
Other commands include:
# View your file history
$ ffsend history
# LINK EXPIRE
1 https://send.vis.ee/#sample-share-url 23h57m
2 https://send.vis.ee/#other-sample-url 17h38m
3 https://example.com/#sample-share-url 37m30s
# Change the password after uploading
$ ffsend password https://send.vis.ee/#sample-share-url
Password: ******
# Delete a file
$ ffsend delete https://send.vis.ee/#sample-share-url
Use the --help flag, help subcommand, or see the help section for
all available subcommands.
Using the snap package is recommended if supported.
Alternatively you may install it manually using the
prebuilt binaries.
Only 64-bit (x86_64) packages and binaries are provided.
For other architectures and configurations you may compile from source.
More packages options will be coming soon.
Linux: snap package
Note: The ffsendsnap package is isolated, and can only access files in
your home directory. Choose a different installation option if you don't want
this limitation.
Note: due to how snap is configured by default, you won't be able to use the
package from some contexts such as through SSH without manual modifications. If
you're experiencing problems, please refer to a different installation method
such as the prebuilt binaries, or open an issue.
_Note: if you want to read/write to a flash drive run snap connect ffsend:removable-media
Note: The Alpine package is maintained by contributors, it might be outdated.
Choose a different installation method if an important update is missing.
Check out the latest release assets for Linux binaries.
Use the ffsend-v*-linux-x64-static binary, to minimize the chance for issues.
If it isn't available yet, you may use an artifact from a
previous version instead, until it is available.
Make sure you meet and install the requirements before you
continue.
You must make the binary executable, and may want to move it into /usr/bin to
make it easily executable:
# Rename binary to ffsend
mv ./ffsend-* ./ffsend
# Mark binary as executable
chmod a+x ./ffsend
# Move binary into path, to make it easily usable
sudo mv ./ffsend /usr/local/bin/
ffsend --help
Check out the latest release assets for a macOS binary.
If it isn't available yet, you may use an artifact from a
previous version instead, until it is available.
Then, mark the downloaded binary as an executable.
You then may want to move it into /usr/local/bin/ to make the ffsend command
globally available:
# Rename file to ffsend
mv ./ffsend-* ./ffsend
# Mark binary as executable
chmod a+x ./ffsend
# Move binary into path, to make it easily usable
sudo mv ./ffsend /usr/local/bin/
ffsend
Check out the latest release assets for Windows binaries.
Use the ffsend-v*-windows-x64-static binary, to minimize the chance for issues.
If it isn't available yet, you may use an artifact from a
previous version instead, until it is available.
You can use ffsend from the command line in the same directory:
.\ffsend.exe --help
To make it globally invocable as ffsend, you must make the binary available in
your systems PATH. The easiest solution is to move it into System32:
A Docker image is available for using ffsend running in a container.
Mount a directory to /data, so it's accessible for ffsend in the container,
and use the command as you normally would.
# Invoke without arguments
docker run --rm -it -v $(pwd):/data timvisee/ffsend
# Upload my-file.txt
docker run --rm -it -v $(pwd):/data timvisee/ffsend upload my-file.txt
# Download from specified link
docker run --rm -it -v $(pwd):/data timvisee/ffsend download https://send.vis.ee/#sample-share-url
# Show help
docker run --rm -it -v $(pwd):/data timvisee/ffsend help
# To update the used image
docker pull timvisee/ffsend
On Linux or macOS you might define a alias in your shell configuration, to make
it invocable as ffsend:
alias ffsend='docker run --rm -it -v "$(pwd):/data" timvisee/ffsend'
Note: This implementation is limited to accessing the paths you make available
through the specified mount.
Build
To build and install ffsend yourself, you meet the following requirements
before proceeding:
It is a better idea to use & modify the existing ffsend port, which manages dependencies for you.
Compile and install
Then, walk through one of the following steps to compile and install ffsend:
Compile and install it directly from cargo:
# Compile and install from cargo
cargo install ffsend -f
# Start using ffsend
ffsend --help
Or clone the repository and install it with cargo:
# Clone the project
git clone https://github.com/timvisee/ffsend.git
cd ffsend
# Compile and install
cargo install --path . -f
# Start using ffsend
ffsend --help
# or run it directly from cargo
cargo run --release -- --help
Or clone the repository and invoke the binary directly (Linux/macOS):
# Clone the project
git clone https://github.com/timvisee/ffsend.git
cd ffsend
# Build the project (release version)
cargo build --release
# Start using ffsend
./target/release/ffsend --help
Compile features / use flags
Different use flags are available for ffsend to toggle whether to include
various features.
The following features are available, some of which are enabled by default:
Feature
Enabled
Description
send2
Default
Support for Send v2 servers
send3
Default
Support for Send v3 servers
crypto-ring
Default
Use ring as cryptography backend
crypto-openssl
Use OpenSSL as cryptography backend
clipboard
Default
Support for copying links to the clipboard
history
Default
Support for tracking files in history
archive
Default
Support for archiving and extracting uploads and downloads
qrcode
Default
Support for rendering a QR code for a share URL
urlshorten
Default
Support for shortening share URLs
infer-command
Default
Support for inferring subcommand based on binary name
no-color
Compile without color support in error and help messages
To enable features during building or installation, specify them with
--features when using cargo.
You may want to disable default features first using
--no-default-features.
Here are some examples:
# Defaults set of features with no-color, one of
cargo install --features no-color
cargo build --release --features no-color
# No default features, except required
cargo install --no-default-features --features send3,crypto-ring
# With history and clipboard support
cargo install --no-default--features --features send3,crypto-ring,history,clipboard
For Windows systems it is recommended to provide the no-color flag, as color
support in Windows terminals is flaky.
Configuration and environment
The following environment variables may be used to configure the following
defaults. The CLI flag is shown along with it, to better describe the relation
to command line arguments:
Variable
CLI flag
Description
FFSEND_HISTORY
--history
History file path
FFSEND_HOST
--host
Upload host
FFSEND_TIMEOUT
--timeout
Request timeout (0 to disable)
FFSEND_TRANSFER_TIMEOUT
--transfer-timeout
Transfer timeout (0 to disable)
FFSEND_EXPIRY_TIME
--expiry-time
Default upload expiry time
FFSEND_DOWNLOAD_LIMIT
--download-limit
Default download limit
FFSEND_API
--api
Server API version, - to lookup
FFSEND_BASIC_AUTH
--basic-auth
Basic HTTP authentication credentials to use.
These environment variables may be used to toggle a flag, simply by making them
available. The actual value of these variables is ignored, and variables may be
empty.
Variable
CLI flag
Description
FFSEND_FORCE
--force
Force operations
FFSEND_NO_INTERACT
--no-interact
No interaction for prompts
FFSEND_YES
--yes
Assume yes for prompts
FFSEND_INCOGNITO
--incognito
Incognito mode, don't use history
FFSEND_OPEN
--open
Open share link of uploaded file
FFSEND_ARCHIVE
--archive
Archive files uploaded
FFSEND_EXTRACT
--extract
Extract files downloaded
FFSEND_COPY
--copy
Copy share link to clipboard
FFSEND_COPY_CMD
--copy-cmd
Copy download command to clipboard
FFSEND_QUIET
--quiet
Log quiet information
FFSEND_VERBOSE
--verbose
Log verbose information
Some environment variables may be set at compile time to tweak some defaults.
Variable
Description
XCLIP_PATH
Set fixed xclip binary path when using clipboard-bin (Linux, *BSD)
XSEL_PATH
Set fixed xsel binary path when using clipboard-bin (Linux, *BSD)
At this time, no configuration or dotfile file support is available.
This will be something added in a later release.
Binary for each subcommand: ffput, ffget
ffsend supports having a separate binaries for single subcommands, such as
having ffput and ffget just for to upload and download using ffsend.
This allows simple and direct commands like:
Support for this feature is only available when ffsend is compiled with the
infer-command feature flag.
This is usually enabled by default.
To verify support is available with an existing installation, make sure the
feature is listed when invoking ffsend debug.
Note that the snap package does currently not support this due to how this
package format works.
Scriptability
ffsend is optimized for use in automated scripts. It provides some specialized
arguments to control ffsend without user interaction.
--no-interact (-I): do not allow user interaction. For prompts not having
a default value, the application will quit with an error, unless --yes
or --force is provided.
This should always be given when using automated scripting.
Example: when uploading a directory, providing this flag will stop the
archive question prompt form popping up, and will archive the directory as
default option.
--yes (-y): assume the yes option for yes/no prompt by default.
Example: when downloading a file that already exists, providing this flag
will assume yes when asking to overwrite a file.
--force (-f): force to continue with the action, skips any warnings that
would otherwise quit the application.
Example: when uploading a file that is too big, providing this flag will
ignore the file size warning and forcefully continues.
--quiet (-q): be quiet, print as little information as possible.
Example: when uploading a file, providing this flag will only output the
final share URL.
Generally speaking, use the following rules when automating:
Always provide --no-interact (-I).
Provide any combination of --yes (-y) and --force (-f) for actions you
want to complete no matter what.
When passing share URLs along, provide the --quiet (-q) flag, when
uploading for example.
These flags can also automatically be set by defining environment variables as
specified here: » Configuration and environment
Here are some examples commands in bash:
# Stop on error
set -e
# Upload a file
# -I: no interaction
# -y: assume yes
# -q: quiet output, just return the share link
URL=$(ffsend -Iy upload -q my-file.txt)
# Render file information
# -I: no interaction
# -f: force, just show the info
ffsend -If info $URL
# Set a password for the uploaded file
ffsend -I password $URL --password="secret"
# Use the following flags automatically from now on
# -I: no interaction
# -f: force
# -y: yes
export FFSEND_NO_INTERACT=1 FFSEND_FORCE=1 FFSEND_YES=1
# Download the uploaded file, overwriting the local variant due to variables
ffsend download $URL --password="secret"
For other questions regarding automation or feature requests, be sure to
open an issue.
Security
In short; the ffsend tool and the Send service can be considered
secure, and may be used to share sensitive files. Note though that the
created share link for an upload will allow anyone to download the file.
Make sure you don't share this link with unauthorized people.
For more detailed information on encryption, please read the rest of the
paragraphs in this security section.
Note: even though the encryption method is considered secure, this ffsend
tool does not provide any warranty in any way, shape or form for files that
somehow got decrypted without proper authorization.
Client side encryption
ffsend uses client side encryption, to ensure your files are securely
encrypted before they are uploaded to the remote host. This makes it impossible
for third parties to decrypt your file without having the secret (encryption
key). The file and its metadata are encrypted using 128-bit AES-GCM, and a
HMAC SHA-256 signing key is used for request authentication.
This is consistent with the encryption documentation provided by the
Send service, ffsend is a tool for.
A detailed list on the encryption/decryption steps, and on what encryption is
exactly used can be found here in the official service
documentation.
Note on share link security
The encryption secret, that is used to decrypt the file when downloading,
is included in the share URL behind the # (hash). This secret is never sent
the remote server directly when using the share link in your browser.
It would be possible however for a webpage to load some malicious JavaScript
snippet that eventually steals the secret from the link once the page is loaded.
Although this scenario is extremely unlikely, there are some options to prevent
this from happening:
Only use this ffsend tool, do not use the share link in your browser.
Add additional protection by specifying a password using --password while
uploading, or using the password subcommand afterwards.
A complete overview on encryption can be found in the official service
documentation here.
Help
$ ffsend help
ffsend 0.2.72
Tim Visee <3a4fb3964f@sinenomine.email>
Easily and securely share files from the command line.
A fully featured Send client.
The default public Send host is provided by Tim Visee, @timvisee.
Please consider to donate and help keep it running: https://vis.ee/donate
USAGE:
ffsend [FLAGS] [OPTIONS] [SUBCOMMAND]
FLAGS:
-f, --force Force the action, ignore warnings
-h, --help Prints help information
-i, --incognito Don't update local history for actions
-I, --no-interact Not interactive, do not prompt
-q, --quiet Produce output suitable for logging and automation
-V, --version Prints version information
-v, --verbose Enable verbose information and logging
-y, --yes Assume yes for prompts
OPTIONS:
-A, --api Server API version to use, '-' to lookup [env: FFSEND_API]
--basic-auth Protected proxy HTTP basic authentication credentials (not FxA) [env: FFSEND_BASIC_AUTH]
-H, --history Use the specified history file [env: FFSEND_HISTORY]
-t, --timeout Request timeout (0 to disable) [env: FFSEND_TIMEOUT]
-T, --transfer-timeout Transfer timeout (0 to disable) [env: FFSEND_TRANSFER_TIMEOUT]
SUBCOMMANDS:
upload Upload files [aliases: u, up]
download Download files [aliases: d, down]
debug View debug information [aliases: dbg]
delete Delete a shared file [aliases: del, rm]
exists Check whether a remote file exists [aliases: e]
generate Generate assets [aliases: gen]
help Prints this message or the help of the given subcommand(s)
history View file history [aliases: h]
info Fetch info about a shared file [aliases: i]
parameters Change parameters of a shared file [aliases: params]
password Change the password of a shared file [aliases: pass, p]
version Determine the Send server version [aliases: v]
This application is not affiliated with Firefox or Mozilla.
